OSS vs Pro

AMFS is GitHub for agent memory, split into two layers. The open-source core gives you the full memory engine with a single-branch repo model — versioning, confidence, outcomes, causal traces, knowledge graph, and a git-like timeline. Pro unlocks the full Git model: branching, merge, pull requests, access control, tags, rollback, cherry-pick, fork — plus multi-tenant SaaS, immutable traces, pattern detection, intelligence, and a dashboard.

At a Glance

┌──────────────────────────────────────────────────────────┐
│                    AMFS Pro (Proprietary)                  │
│                                                          │
│  ┌─ Memory Branching (Git for Agent Memory) ───────────┐ │
│  │  Branches · Merge · PRs · Diff · Access Control      │ │
│  │  Tags/Snapshots · Rollback · Cherry-pick · Fork      │ │
│  │  Branch-Level Permissions (user/team/API key)        │ │
│  │  Sacred Timeline (3D visualization)                   │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
│  ┌─ Multi-Tenant SaaS ─────────────────────────────────┐ │
│  │  Accounts · RBAC · Scoped API Keys · Audit · Quotas │ │
│  │  Row-Level Security · OAuth/OIDC · Rate Limiting     │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
│  ┌─ Immutable Decision Trace Store ────────────────────┐ │
│  │  Durable Causal Chains · Cryptographic Integrity     │ │
│  │  LLM Call Spans · Token/Cost Tracking · Replay       │ │
│  │  Enriched Traces · Error Events · State Diff         │ │
│  │  OpenTelemetry Export · Precedent Search              │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
│  ┌─ Cross-System Ingestion ───────────────────────────┐   │
│  │  Webhooks · HMAC Verification · Deduplication        │ │
│  │  PagerDuty · Slack · GitHub · Jira Connectors        │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
│  ┌─ Automated Pattern Detection ──────────────────────┐   │
│  │  Recurring Failures · Hot Entities · Stale Clusters  │ │
│  │  Confidence Drift · Configurable Alert Rules         │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
│  ┌─ Intelligence Layer ─────────────────────────────────┐ │
│  │  Extraction · Critic · Distiller · Safety · Retrieval │ │
│  │  Learned Ranking · Confidence Calibration · ML Export │ │
│  │  LLM Importance Scoring · TierWorker (background)    │ │
│  │  Auto Entity/Relationship Extraction from Traces     │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
│  ┌─ Dashboard ──────────────────────────────────────────┐ │
│  │  Memory Explorer · Interactive Causal Graph           │ │
│  │  Trace Detail with Enriched Context · Agent Graph     │ │
│  │  Sacred Timeline (3D) · Branch Manager · PR Viewer   │ │
│  │  API Key Console · Audit Viewer · Usage Analytics    │ │
│  │  Cursor plugin (hosted MCP to Pro API)              │ │
│  │  Pattern Detection · Memory Tiers · Snapshots        │ │
│  │  Team Management                                    │ │
│  └──────────────────────────────────────────────────────┘ │
│                                                          │
├──────────────────────────────────────────────────────────┤
│                    AMFS OSS (Apache 2.0)                  │
│                                                          │
│  CoW Engine · Memory Types · Provenance Tiers             │
│  Git-like Timeline (event logging on main branch)        │
│  Branch-Aware Read/Write/List/Search (main default)      │
│  Temporal Queries · Session-Level Causal Explainability   │
│  Enriched Decision Traces · Query/Error Event Tracking    │
│  Composite Recall Scoring · Multi-Scope Search            │
│  Knowledge Graph (auto-materialized edges)               │
│  Hybrid Search (full-text + semantic + composite)         │
│  Tiered Memory (Hot/Warm/Archive) · Priority Scoring      │
│  Frequency-Modulated Decay · Cortex Drift Gate            │
│  ImportanceEvaluator ABC · Progressive Retrieval          │
│  Per-Agent Memory Graph · Agent Activity Timeline         │
│  Connector Framework · CLI · Built-in Connectors          │
│  Webhook Receiver · Adapters (FS, Postgres, S3)           │
│  HTTP/REST API · MCP Server · Python SDK · TS SDK · CLI   │
│  Docker + Helm Charts                                     │
└──────────────────────────────────────────────────────────┘

Feature Comparison

Capability	OSS	Pro
Core Memory Primitives
Copy-on-Write versioning	Yes	Yes
Confidence scoring with outcome back-propagation	Yes	Yes
Memory types (fact, belief, experience)	Yes	Yes
Type-specific confidence decay	Yes	Yes
Provenance tiers (production-validated → manual)	Yes	Yes
Temporal queries (`history`)	Yes	Yes
Session-level causal explainability (`explain`)	Yes	Yes
Enriched decision traces (query events, error events, state diff)	Yes	Yes
Session timing and per-operation latency tracking	Yes	Yes
Per-agent memory graph and activity timeline	Yes	Yes
Composite recall scoring	Yes	Yes
Multi-scope search	Yes	Yes
Knowledge graph (auto-materialized from writes/outcomes)	Yes	Yes
Hybrid search (full-text + semantic + composite scoring)	Yes	Yes
Frequency-modulated decay (4-signal model)	Yes	Yes
Tiered memory (Hot / Warm / Archive)	Yes	Yes
Progressive retrieval (`depth`)	Yes	Yes
Importance evaluator hook (`ImportanceEvaluator` ABC)	Yes	Yes
Cortex drift gate (skip-redundant recompilations)	Yes	Yes
LLM importance scoring (3-dimension)	—	Yes
Background tier recomputation (`TierWorker`)	—	Yes
Git-like Timeline
Event logging (writes, outcomes, reads, briefs) on main	Yes	Yes
Branch-aware read/write/list/search (`branch` parameter)	Yes	Yes
Timeline API endpoint per agent	Yes	Yes
MCP `amfs_timeline` tool	Yes	Yes
Memory Branching (Pro)
Create / close / list branches	—	Yes
Diff branch vs. main	—	Yes
Merge branches (fast-forward, ours, theirs)	—	Yes
Branch access control (grant/revoke per user/team/API key)	—	Yes
Access enforcement on non-main read/write	—	Yes
Pull Requests with review workflow	—	Yes
Tags / named snapshots	—	Yes
Rollback to tag or timestamp	—	Yes
Cherry-pick entries across branches	—	Yes
Fork agent memory to a new agent	—	Yes
Sacred Timeline (3D interactive visualization)	—	Yes
Connectors
Connector framework (`ConnectorABC`)	Yes	Yes
Connector CLI (`amfs connector install/list/remove`)	Yes	Yes
Built-in connectors (PagerDuty, GitHub, Slack, Jira)	Yes	Yes
Webhook receiver (`/api/v1/webhooks/{name}`)	Yes	Yes
Adapters & Infrastructure
Filesystem adapter	Yes	Yes
Postgres adapter (triggers, LISTEN/NOTIFY)	Yes	Yes
S3 adapter	Yes	Yes
HTTP/REST API server	Yes	Yes
Docker + Docker Compose + Helm charts	Yes	Yes
MCP server (12 tools)	Yes	Yes
SDKs & Clients
Python SDK (full parity)	Yes	Yes
TypeScript SDK (full parity)	Yes	Yes
CLI tools	Yes	Yes
Framework integrations (CrewAI, LangGraph, etc.)	Yes	Yes
Bundled lightweight embedder	Yes	Yes
Multi-Tenant SaaS (Pro)
Account-level tenant isolation (RLS)	—	Yes
RBAC (Admin, Developer, User)	—	Yes
Scoped API keys with entity-path permissions	—	Yes
Permissioned inference (scope-filtered search/explain)	—	Yes
OAuth 2.0 / OIDC for dashboard users	—	Yes
Append-only audit logging	—	Yes
Usage quotas + sliding-window rate limiting	—	Yes
Immutable Decision Trace Store (Pro)
Durable causal chains across sessions	—	Yes
Cryptographic signing (HMAC-SHA256) and Merkle chain linking	—	Yes
LLM call span tracking (model, tokens, cost, latency)	—	Yes
Write events, tool calls, and agent interaction recording	—	Yes
OpenTelemetry export (GenAI semantic conventions)	—	Yes
Historical `explain(outcome_ref)`	—	Yes
`search_traces` / precedent search API	—	Yes
Cross-agent, cross-session trace queries	—	Yes
Cross-System Ingestion
Generic webhook endpoint with HMAC verification	Yes	Yes
Payload deduplication (idempotency)	Yes	Yes
Pluggable transform pipeline with pattern matching	Yes	Yes
PagerDuty incident connector	Yes	Yes
Extensible connector framework (`ConnectorABC`)	Yes	Yes
Automated Pattern Detection (Pro)
Recurring failure detection across causal chains	—	Yes
Hot entity detection (disproportionate activity)	—	Yes
Stale cluster detection (unvalidated entries)	—	Yes
Confidence drift detection (outlier entries)	—	Yes
Configurable alert rules with cooldown suppression	—	Yes
Alert callbacks (Slack, PagerDuty, email routing)	—	Yes
Intelligence Layer (Pro)
LLM-driven memory extraction	—	Yes
Auto entity/relationship extraction from traces	—	Yes
Automated memory critic	—	Yes
Memory distillation & bootstrap sets	—	Yes
Memory safety validation	—	Yes
Multi-strategy retrieval with learned ranking (RRF + ML)	—	Yes
Learned retrieval ranking from outcome data	—	Yes
Adaptive confidence calibration	—	Yes
Training data export (SFT, DPO, reward model)	—	Yes
Dashboard (Pro)
Memory explorer with interactive causal graph	—	Yes
Decision trace explorer with enriched context and causal graph	—	Yes
Per-agent memory graph and activity timeline	—	Yes
Pattern detection dashboard with severity indicators	—	Yes
Team & user management with roles	—	Yes
API key management console with scopes	—	Yes
Audit log viewer with search/filter	—	Yes
Usage analytics & quota monitoring	—	Yes
Snapshot capture, compare, and export	—	Yes
Memory Tiers dashboard (distribution, entry browser)	—	Yes
Extended MCP server (Pro tools)	—	Yes

Hosted SaaS Tiers (SenseLab Cloud)

Stripe, subscriptions, and the tenant control plane are implemented in the private SenseLab amfs-internal repository (not in the open-source tree). Self-serve tiers are summarized below; see also Hosted billing & metering.

Tier	Indicative price	Included ops / month	Notes
Free	$0	1K	Solo; no team invites; hard cap
Starter	$29	25K	Entry tier; auto top-up near limit (paid)
Pro	$149	50K	Production agent teams
Teams	$449	300K	Org scale; lower overage unit / 10K ops
Enterprise	Custom	Custom	SSO, committed volume, SLA

Ops (hosted): read-like calls typically 1 op, writes 2 ops, commit_outcome 0 ops. The HTTP + MCP mapping lives in the metering guide linked above. Onboarding: Users must choose a plan (including Free) before the dashboard unlocks; paid plans complete Stripe Checkout and activation via webhooks (not browser success URL alone).

OSS Layer — What’s Included

The open-source layer (github.com/raia-live/amfs) provides the full memory primitive: read, write, version, search, and learn from outcomes. It includes a git-like timeline engine, branch-aware operations, a connector framework, composite recall scoring, multi-scope search, a knowledge graph auto-materialized from writes and outcomes, hybrid search (full-text + semantic + composite scoring), tiered memory (Hot/Warm/Archive with progressive retrieval), frequency-modulated decay (4-signal model), and a Cortex drift gate that avoids redundant digest recompilations.

Packages

Package	Description
`amfs-core`	CoW engine, models, read tracking, causal tagging, default embedder, `tiering` (PriorityScorer, TierAssigner), `importance` (ImportanceEvaluator ABC)
`amfs` (SDK)	`AgentMemory` class — `read`, `write`, `list`, `search`, `history`, `timeline`, `explain`, `commit_outcome`, `record_context`
`amfs-adapter-filesystem`	JSON-file-based adapter for local development
`amfs-adapter-postgres`	PostgreSQL adapter with PL/pgSQL triggers for outcome propagation and `LISTEN/NOTIFY` for watch
`amfs-adapter-s3`	Amazon S3 / S3-compatible adapter for cloud-native storage
`amfs-http-server`	REST API server (FastAPI/Uvicorn) for remote access, branch-aware endpoints
`amfs-mcp-server`	MCP server exposing 12 tools: `amfs_read`, `amfs_write`, `amfs_search`, `amfs_retrieve`, `amfs_list`, `amfs_stats`, `amfs_commit_outcome`, `amfs_record_context`, `amfs_history`, `amfs_explain`, `amfs_graph_neighbors`, `amfs_timeline`
`amfs-cli`	Terminal tools for inspecting, diffing, snapshotting, and restoring memory
`@amfs/sdk`	TypeScript SDK (full parity with Python: ReadTracker, search, stats, history, explain, recordContext)

Key Primitives

Memory Types — Every entry is classified as fact, belief, or experience, each with its own decay rate:

from amfs import AgentMemory, MemoryType

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

mem.write("svc", "config", {"pool": 10}, memory_type=MemoryType.FACT)
mem.write("svc", "hypothesis", "Likely N+1", memory_type=MemoryType.BELIEF)
mem.write("svc", "action-log", "Added index", memory_type=MemoryType.EXPERIENCE)

Provenance Tiers — Entries are automatically ranked by quality based on how they were created:

from amfs import ProvenanceTier

entry = mem.read("svc", "pattern")
if entry.provenance_tier == ProvenanceTier.PRODUCTION_VALIDATED:
    print("Validated by production outcomes")

Temporal Queries — Retrieve the full version history of any entry:

versions = mem.history("svc", "retry-pattern", since=last_week)

Causal Explainability — See which entries were read and how they connect to outcomes:

chain = mem.explain()

Pro Layer — What’s Added

The Pro layer wraps the OSS layer — it never replaces it. All Pro features read from and write to the same memory store using the same adapters and SDK.

Memory Branching — Git for Agent Memory

The defining Pro feature. While OSS provides the git-like timeline engine (event logging on main), Pro adds the full branching model — branches, merge, pull requests, access control, tags, rollback, cherry-pick, and fork. Agents create isolated branches to experiment, then merge changes back into main after review.

Memory Branching Deep Dive

Full documentation on branches, merge strategies, pull requests, access control, tags, rollback, cherry-pick, fork, and the Sacred Timeline visualization.

Multi-Tenant SaaS Foundation

The foundation for running AMFS as a hosted service. Every API request is authenticated, authorized, scoped, and audited. Includes account-level Postgres RLS isolation, three-role RBAC (Admin/Developer/User), scoped API keys with entity-path permissions, and sliding-window rate limiting.

Multi-Tenant SaaS

Account isolation, RBAC, scoped API keys, OAuth/OIDC, audit logging, rate limiting, and usage quotas.

Immutable Decision Trace Store

The OSS explain() works within the active session and captures enriched trace data (query events, error events, session timing, state diffs). Pro builds on this with persistent, cryptographically signed, immutable traces — the full causal chain is queryable forever. Includes LLM call span tracking with token/cost analytics and OpenTelemetry export.

Decision Trace Store

Durable causal chains, cryptographic integrity, LLM call spans, precedent search, and OpenTelemetry export.

Cross-System Ingestion

Automatically ingest events from external systems into AMFS memory. The connector framework transforms raw events into AMFS write() or record_context() operations, with HMAC verification, deduplication, and pluggable transforms.

Cross-System Ingestion

Webhook ingester, connector framework, and built-in connectors for PagerDuty, Slack, GitHub, and Jira.

Automated Pattern Detection

Continuously analyze your memory store to surface recurring patterns, anomalies, and risks — before they become incidents. Detects recurring failures, hot entities, stale clusters, and confidence drift with configurable alert rules and cooldown-based suppression.

Pattern Detection

Pattern types, severity levels, alert rules, cooldown suppression, and callback routing.

Intelligence Layer

LLM-powered tools for memory quality and retrieval: extraction (raw text → structured operations), memory critic (toxic/stale/contradictory detection), distiller (compact stores into bootstrap sets), safety validator (pre-write guardrails), multi-strategy retrieval with learned ranking, adaptive confidence calibration, and training data export (SFT, DPO, reward model).

Intelligence Layer

Extraction, critic, distiller, safety, retrieval, ML ranking, calibration, and training data export.

Dashboard

A web dashboard (Next.js 15 + React 19) for exploring memory, visualizing decisions, and managing your AMFS deployment.

Page	Description
Overview	Account-wide stats, recent activity, health indicators, live SSE status
Entities	Browse entities, view entries with confidence badges, version history, provenance details
Traces	Enriched trace cards with causal entries, external contexts, query/error events, session timing, outcome badges, and search/filter
Trace Detail	Full trace view with interactive causal graph (D3), timeline, entry snapshots, and state diff
Agents	Per-agent overview with memory graph, activity, and Git Repository section
Incidents	Incident timeline with causal chain drill-down
Patterns	Detected pattern dashboard with severity indicators and resolution tracking
Teams	Team CRUD with member management (admin, developer, viewer roles)
Snapshots	Memory snapshot capture, comparison, and JSON export
API Keys	Key management console with scopes, rate limits, expiry, and usage
Audit Log	Searchable, filterable log of all state-changing operations
Usage & Quotas	Quota progress bars, request metrics, top agents/entities breakdown
Pro Tools	Retrieval playground, critic panel, distiller view, calibration dashboard, training data export

Dashboard Guide

Full walkthrough of every dashboard page, the Agent Git Repository section, and the Sacred Timeline.

Architecture

┌─────────────────────────────────────────────────────────────┐
│                        Agent / IDE                          │
└────────────────────────────┬────────────────────────────────┘
                             │
              ┌──────────────┴──────────────┐
              ▼                             ▼
   ┌─────────────────┐          ┌───────────────────────────┐
   │  MCP Server OSS │          │  MCP Server Pro            │
   │  (12 tools)     │          │  (12 + 8 tools)            │
   └────────┬────────┘          │                           │
            │                   │  Branching Layer:         │
            │                   │  Branches · Merge · PRs   │
            │                   │  Access Control · Tags    │
            │                   │  Rollback · Fork          │
            │                   │                           │
            │                   │  Multi-Tenant Layer:      │
            │                   │  Auth · RBAC · RLS        │
            │                   │  Scopes · Audit · Quotas  │
            │                   │  Rate Limiting             │
            │                   │                           │
            │                   │  Decision Traces:         │
            │                   │  Recorder · Store · Search │
            │                   │                           │
            │                   │  Ingestion Layer:         │
            │                   │  Webhooks · Connectors    │
            │                   │  PagerDuty · Slack · etc. │
            │                   │                           │
            │                   │  Pattern Detection:       │
            │                   │  Detector · AlertManager  │
            │                   │                           │
            │                   │  Intelligence Layer:       │
            │                   │  Critic · Distiller        │
            │                   │  Safety · Retrieval        │
            │                   │                           │
            │                   │  ML Layer:                │
            │                   │  Ranking · Calibration    │
            │                   │  Training Data Export     │
            │                   └─────────────┬─────────────┘
            │                                 │
            └──────────┬──────────────────────┘
                       ▼
            ┌─────────────────┐
            │   AgentMemory   │  ← Python / TypeScript SDK
            │   (CoW Engine)  │
            │   + Timeline    │  ← Git-like event log
            └────────┬────────┘
                     │
           ┌─────────┼─────────┐
           ▼         ▼         ▼
      Filesystem  Postgres    S3
       Adapter    Adapter   Adapter

The Pro API layer wraps AgentMemory and CoWEngine with authentication, tenant isolation, scope enforcement, rate limiting, and audit logging — all backed by Postgres RLS for defense-in-depth.

When to Use Which

Scenario	Recommendation
Single developer, local memory	OSS
Small team sharing via Postgres	OSS
CI/CD outcome tracking	OSS
Remote HTTP API access	OSS
S3-based cloud storage	OSS
Git-like timeline (event logging on main branch)	OSS
Branch-aware read/write (main branch only)	OSS
Create branches and share memory selectively	Pro (branching)
Branch access control per user/team/API key	Pro (branching)
Merge branches, resolve conflicts	Pro (branching)
Pull request workflow for memory changes	Pro (branching)
Rollback memory to a point in time or tag	Pro (branching)
Fork agent memory to new agents	Pro (branching)
Sacred Timeline 3D visualization	Pro (dashboard)
Multi-tenant SaaS with account isolation	Pro
Scoped API keys per agent/tool	Pro
Compliance audit logging	Pro
Enriched decision traces with error/query events and session timing	OSS
Per-agent memory graph and activity timeline	OSS
Immutable, cryptographically signed traces	Pro
LLM call span tracking with token/cost analytics	Pro
OpenTelemetry export for existing observability stacks	Pro
Auto entity/relationship extraction from traces	Pro
Precedent search (“how did we handle similar situations?”)	Pro
Auto-ingest PagerDuty/Slack/GitHub events	Pro (connectors)
Detect recurring failure patterns automatically	Pro (pattern detection)
Alert on stale memory or confidence drift	Pro (alert manager)
Need memory quality auditing at scale	Pro
Want LLM-driven extraction from conversations/logs	Pro
Onboarding new agents with curated knowledge	Pro (bootstrap sets)
Compliance or safety requirements for memory writes	Pro (safety validator)
Advanced retrieval across large stores	Pro (multi-strategy + learned ranking)
Retrieval that improves as outcomes accumulate	Pro (ML layer)
Need optimized confidence multipliers per entity	Pro (adaptive calibration)
Want to fine-tune agents on your decision history	Pro (training data export)
Team dashboard for non-technical users	Pro (dashboard)

Getting Started

OSS Quick Start

Install with pip install amfs and start writing memory in minutes.

Product

Getting Started

Guides

Core Concepts

Pro Features

At a Glance

Feature Comparison

Hosted SaaS Tiers (SenseLab Cloud)

OSS Layer — What’s Included

Packages

Key Primitives

Pro Layer — What’s Added

Memory Branching — Git for Agent Memory

Memory Branching Deep Dive

Multi-Tenant SaaS Foundation

Multi-Tenant SaaS

Immutable Decision Trace Store

Decision Trace Store

Cross-System Ingestion

Cross-System Ingestion

Automated Pattern Detection

Pattern Detection

Intelligence Layer

Intelligence Layer

Dashboard

Dashboard Guide

Architecture

When to Use Which

Getting Started

OSS Quick Start

Pro Access

Product

Getting Started

Guides

Core Concepts

Pro Features

​At a Glance

​Feature Comparison

​Hosted SaaS Tiers (SenseLab Cloud)

​OSS Layer — What’s Included

​Packages

​Key Primitives

​Pro Layer — What’s Added

​Memory Branching — Git for Agent Memory

Memory Branching Deep Dive

​Multi-Tenant SaaS Foundation

Multi-Tenant SaaS

​Immutable Decision Trace Store

Decision Trace Store

​Cross-System Ingestion

Cross-System Ingestion

​Automated Pattern Detection

Pattern Detection

​Intelligence Layer

Intelligence Layer

​Dashboard

Dashboard Guide

​Architecture

​When to Use Which

​Getting Started

OSS Quick Start

Pro Access

At a Glance

Feature Comparison

Hosted SaaS Tiers (SenseLab Cloud)

OSS Layer — What’s Included

Packages

Key Primitives

Pro Layer — What’s Added

Memory Branching — Git for Agent Memory

Multi-Tenant SaaS Foundation

Immutable Decision Trace Store

Cross-System Ingestion

Automated Pattern Detection

Intelligence Layer

Dashboard

Architecture

When to Use Which

Getting Started