Historical v3.5 scale-readiness label · current evidence pending

Memory that
scales with you.

v3.5 introduced bounded-storage controls, multi-agent coordination work, and cold-tier experiments. Current release guarantees are limited to behavior covered by the release test evidence.

Bounded
Configurable storage controls
Measured
Content-specific compression
Pending
Release-linked latency envelope
Pending
Verified concurrency envelope
What Scale Readiness Requires

Production constraints
need measured evidence.

V3 includes lifecycle, storage, coordination, and audit controls. A production claim additionally requires release-linked quality, latency, recovery, concurrency, and resource evidence.

01 // BOUNDED

Explicit lifecycle controls.

SQLite remains the canonical source of truth. V3.7 includes CozoDB and LanceDB scale-engine paths, each protected by prepare, verify, promote, and rollback controls rather than an automatic backend switch.

Verify bounds and recovery on your corpus
02 // CONCURRENT

Local coordination primitives.

SLM Mesh exposes peer, lock, event, inbox, and state primitives. Publish a concurrency number only after the frozen release passes contention, recovery, and consistency tests.

Concurrency envelope pending
03 // COMPRESSED

Content-specific cold tier.

Cold-tier and compression behavior depend on the configured path and content. Measure fidelity, reduction, retrieval quality, and latency before enabling it in production.

Measure compression and recall on representative data
04 // PRIVATE

Inspectable local controls.

Core memory operations can run locally and produce structured evidence. Optional providers, connectors, backups, proxies, and downloads may use the network.

Audit the configured deployment
SLM Mesh · Optional coordination surface

Cross-agent coordination
primitives.

Configured callers can coordinate work and target one explicitly selected SLM service. Mesh does not by itself replicate memories or turn multiple local stores into one distributed database.

SLM Mesh is a local coordination layer with lock, event, inbox, peer, and shared-state tools. It is not evidence of distributed memory replication or universal consistency.

  • Mesh lock — per-key optimistic locking with timeout and retry backoff
  • Mesh events — local event routing; measure delivery latency under the target workload
  • Mesh peers — agents announce presence; stale-peer and expired-lock cleanup must be verified under failure
  • Mesh inbox — directed messages between named agent roles
  • Mesh state — shared ephemeral state for task handoff and coordination
🤖
Planner
SLM Mesh
🤖
Executor
🤖
Critic
Configured
SLM Endpoint
🤖
Researcher

Selected endpoint · local locks · events · inbox

mesh_peers() → inspect authenticated peer list
mesh_lock("task_42") → inspect owner, expiry, and result
mesh_send(to="Executor") → inspect delivery receipt
mesh_status() → inspect runtime health
Performance Benchmarks · M5 Pro, 2026

Measured. Not claimed.

The historical table below is retained as design context, not a current V3.7 release claim. Re-run the release benchmark harness on representative data before publishing numbers.

Operation p50 p95 p99 Memory size Notes
Current V3.7 latency and scale results are not published. Run the release benchmark harness on representative hardware, corpus shape, and concurrency before setting an SLO.
Deployment Patterns

One install. Three deployment shapes.

SLM adapts to your workflow — solo developer, multi-agent pipeline, or team shared memory server.

Solo Agent

Single-client deployment using the local core. Run setup explicitly; Optimize cache and compression remain separately configured.

Mode A pipx / uv Explicit setup

Multi-Agent Mesh

Multiple local agents using SLM Mesh coordination primitives. Validate contention, crash recovery, and state consistency for the target process topology.

SLM Mesh Envelope pending Local lock tools

MCP Server Mode

SLM exposed as an MCP server. Tool availability depends on the selected profile and release; client compatibility requires a successful end-to-end contract, not only protocol support.

MCP protocol Profile-selected tools Client verification required
Scale Configuration

Validate configuration
against the shipped schema.

Do not copy invented scale knobs from marketing pages. Inspect the installed configuration schema, set only supported fields, and verify the resulting runtime behavior.

~/.superlocalmemory/config.toml
# Inspect release-current commands and configuration
slm status --json
slm doctor
slm cache status
slm compress status

# Back up the configured data root before changing modes,
# lifecycle policy, cache, compression, or mesh settings.
# Then run representative quality, latency, recovery,
# concurrency, disk, and memory tests.
Upgrade Guide

Upgrade without
assuming scale guarantees.

Back up first, upgrade through the original installer, and verify migration before serving client traffic.

1

Upgrade the package

Use the same isolated installer that owns the current executable. Do not mutate a system Python installation.

pipx upgrade superlocalmemory # or: uv tool upgrade superlocalmemory
2

Run migration and health checks

Start from a copied data root, run the supported migration path, and verify remember, recall, update, forget, restart, and recovery.

slm doctor slm status --json
3

Optionally enable SLM Mesh

Enable optional cache, compression, backends, providers, or mesh features only after their target-workload tests pass.

slm cache status slm compress status

Prove scale readiness before deployment.

Install the release, set explicit storage limits, and benchmark your representative corpus before production use.