Agent Memory

Persistent memory for AI agents to store facts, learn from actions, recall information, and track entities across sessions.

Security Scan

This skill is internally coherent: it implements a local SQLite-backed agent memory (reads/writes ~/.agent-memory/memory.db by default), requires no credentials or external network access, and its files match the SKILL.md usage.

Purpose & Capability

Name, README, SKILL.md, CLI wrappers, examples, tests, and src/memory.py all describe and implement a local persistent memory system using SQLite. There are no unrelated requirements (no cloud credentials, no network libraries) that would contradict the stated purpose.

Instruction Scope

SKILL.md instructs the agent to instantiate AgentMemory and call methods such as remember(), recall(), learn(), and track_entity(). The code implements exactly those behaviors and only accesses the configured SQLite DB path (default ~/.agent-memory/memory.db). There are no instructions that read unrelated system files, transmit data to external endpoints, or access unexpected environment variables.

Install Mechanism

No install spec is provided (instruction-only skill). The package includes source files but does not declare external installs or downloads; requirements.txt is empty. This is low-risk from an install perspective.

Credentials

The skill declares no required environment variables, no credentials, and no config paths beyond an optional db_path constructor argument. This is proportional for a local memory store.

Persistence & Privilege

The skill persists data to disk by default at ~/.agent-memory/memory.db and creates that directory if missing. always is false and the skill does not request elevated privileges, but it will store potentially sensitive text in an unencrypted SQLite file unless the integrator specifies a different db_path or provides encryption. Consider this permanant-on-disk persistence when deciding to install.

Assessment

This skill appears to do what it says: a local, file-backed memory for agents. Before installing, consider: 1) Data sensitivity — memories are stored in plaintext SQLite by default (~/.agent-memory/memory.db); avoid writing secrets (passwords, API keys) into it or point it to a custom path you control. 2) File permissions — restrict access to the DB file (e.g., chmod 600). 3) Backup / retention — decide how long you want memories kept or enable expiry when calling remember(). 4) If you need encryption or remote storage, modify the code or supply an encrypted DB. The code contains no network calls or credential exfiltration patterns, and tests exercise local behavior, so it looks safe to use with the precautions above.

AgentMemory Skill

Persistent memory system for AI agents. Remember facts, learn from experience, and track entities across sessions.

Installation

clawdhub install agent-memory

Usage

from src.memory import AgentMemory

mem = AgentMemory()

# Remember facts
mem.remember("Important information", tags=["category"])

# Learn from experience
mem.learn(
    action="What was done",
    context="situation",
    outcome="positive",  # or "negative"
    insight="What was learned"
)

# Recall memories
facts = mem.recall("search query")
lessons = mem.get_lessons(context="topic")

# Track entities
mem.track_entity("Name", "person", {"role": "engineer"})

When to Use

• Starting a session: Load relevant context from memory
• After conversations: Store important facts
• After failures: Record lessons learned
• Meeting new people/projects: Track as entities

Integration with Clawdbot

Add to your AGENTS.md or HEARTBEAT.md:

## Memory Protocol

On session start:
1. Load recent lessons: `mem.get_lessons(limit=5)`
2. Check entity context for current task
3. Recall relevant facts

On session end:
1. Extract durable facts from conversation
2. Record any lessons learned
3. Update entity information

Database Location

Default: ~/.agent-memory/memory.db

Custom: AgentMemory(db_path="/path/to/memory.db")