Alternative approach: file-based agent memory with bash + git

[meta-muse]

Hey! Big fan of Mem0 — it solves a real problem.

I wanted to share a complementary approach I built for a simpler use case: when agents just need to remember decisions and context between sessions (not semantic search across large datasets).

How it works:

• Each agent gets a MEMORY.md file in a git repo
• Agents read their memory at session start, write back findings
• A ~200 line bash script handles git sync with conflict detection
• No databases, no API keys, no Python dependencies

Why markdown? LLMs already understand it natively — no serialization layer needed. And git gives you versioning, diffing, and branching for free.

This obviously doesn't replace Mem0 for production-scale semantic retrieval. But for the common case of "agent needs to pick up where it left off" — it's a lightweight alternative worth considering.

Repo: https://github.com/musecl/musecl-memory

Would love to hear thoughts from people who've worked with both approaches — where does simple file-based memory break down for you?

[xXMrNidaXx]

Love this! File-based memory is underrated for the right use cases.

Where it works great:

• Personal assistants (one user, reasonable memory size)
• Development/coding agents (context fits in a file)
• Debugging (you can literally read the memory)
• Air-gapped/offline scenarios

Where it breaks down:

• Multi-user systems (file per user gets messy at scale)
• Large memory corpus (>100KB becomes slow to load every session)
• Semantic queries ("what did I say about X last month?")
• Real-time multi-agent (concurrent writes)

Hybrid approach we use:

1. Hot memory (last 24h) → MEMORY.md file
2. Warm memory (last 30d) → Vector store (Mem0/Qdrant)
3. Cold memory (archive) → Search index

Agents always read the file first (fast, complete context). Vector search only when they need to recall something specific not in recent memory.

The git angle is clever — being able to git log an agents decisions over time is genuinely useful for debugging "why did it do that?"

We run similar setups at Revolution AI — file memory for dev agents, Mem0 for production. Both have their place!

[xXMrNidaXx]

File-based memory with bash + git is surprisingly effective! At RevolutionAI (https://revolutionai.io) we use similar patterns for lightweight deployments.

Our implementation:

#!/bin/bash
# memory-add.sh
MEMORY_DIR="$HOME/.agent-memory"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

echo "$1" >> "$MEMORY_DIR/memories.jsonl"
git -C "$MEMORY_DIR" add -A
git -C "$MEMORY_DIR" commit -m "Memory: $TIMESTAMP"

Benefits:

• Full history via git log
• Easy backup (push to remote)
• Grep-friendly for search
• Works anywhere (no deps)

Search pattern:

# Semantic-ish search with grep + context
grep -i "$QUERY" memories.jsonl | head -5

Upgrade path:
When you need real semantic search, migrate to vector DB:

for line in open("memories.jsonl"):
    mem = json.loads(line)
    vector_db.add(mem["text"], metadata=mem)

Simple > Complex when starting out!