# Hedgehog Memory

> Radial memory architecture for AI agents — infinite persistent memory with hierarchical compression. Never deletes, only compresses. Origin always in context. pip install hedgehog-memory.

- Skill: `lord1egypt/hedgehog-memory` (Agent Skill)
- Install (CLI): `npx skillmds@latest add lord1egypt/hedgehog-memory`
- Raw SKILL.md: https://api.skillmd.com/api/skills/lord1egypt/hedgehog-memory/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: Lord1Egypt (https://skillmd.com/u/lord1egypt)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/lord1egypt/hedgehog-memory

---


# HedgehogMemory

HedgehogMemory gives AI agents **infinite persistent memory** using a radial compression architecture. Memory is organized as Lines of Nodes — each Node stores the same content at 5 abstraction levels (L0–L4). The L0 one-liner of every node is always loaded at session start (~200 tokens total), so the agent always knows what it knows.

**Key guarantee:** Memory is NEVER deleted. Old context is only compressed into smaller abstractions. The verbatim original is always recoverable at L4.

## Installation

```
pip install hedgehog-memory
pip install "hedgehog-memory[openai]"   # with OpenAI summarizer (recommended)
```

## Abstraction Levels

| Level | Max length | Use case |
|-------|-----------|----------|
| L0 | 80 chars | One-liner, always in context |
| L1 | 200 chars | Navigation preview |
| L2 | 600 chars | Detailed summary |
| L3 | 1800 chars | Full context summary |
| L4 | unlimited | Verbatim original |

## Quick Start

```python
from radial_memory import ContextWindowManager
import os

mgr = ContextWindowManager(
    base_path=os.environ.get("HEDGEHOG_MEMORY_PATH", "./memory_store")
)

# SESSION START: get ~200-token origin overview (all L0 summaries)
overview = mgr.reset()
print(overview)  # inject this into your system prompt

# LOAD: find relevant past context by query
result = mgr.load("Python async patterns")
if result.found:
    print(result.content)   # L1 summary by default
    result = result.drill_deeper()     # go to L2
    full = result.load_full_state()    # get verbatim original (L4)

# COMMIT: save current session to memory
mgr.commit(
    topic="Async Python debugging session",
    full_context="Complete session transcript goes here...",
    tags=["python", "async", "debugging"]
)
```

## With OpenAI Summarizer (recommended for quality)

```python
from radial_memory import ContextWindowManager
from radial_memory.summarizer import OpenAISummarizer
import os

summarizer = OpenAISummarizer(
    api_key=os.environ["OPENAI_API_KEY"],
    model="gpt-4o-mini"
)
mgr = ContextWindowManager(
    base_path=os.environ.get("HEDGEHOG_MEMORY_PATH", "./memory_store"),
    summarizer=summarizer
)
```

## Agent Workflow Pattern

Apply this pattern every session:

```python
# 1. SESSION START
overview = mgr.reset()
# overview = all L0 one-liners for every stored node (~200 tokens)
# Inject overview into your system prompt / context window

# 2. QUERY - find relevant past context
result = mgr.load(query=user_request)
if result.found:
    context = result.content  # L1 summary, ~200 chars
    # Need more detail?
    result = result.drill_deeper()   # L2, ~600 chars
    result = result.drill_deeper()   # L3, ~1800 chars
    full = result.load_full_state()  # L4, verbatim original

# 3. WORK - perform task with full context available

# 4. COMMIT - persist session to memory
mgr.commit(
    topic="Brief description of this session",
    full_context=full_session_log,
    tags=["topic1", "topic2"]
)
```

## Status Report

```python
report = mgr.status_report()
# Returns: total lines, total nodes, last commit timestamp
print(report)
```

## Design Principles

- **Never deletes** — only compresses. The verbatim original is always recoverable.
- **Origin always in context** — L0 summaries of all nodes load at session start (~200 tokens).
- **Radial navigation** — query finds the most relevant node by keyword overlap, then drill deeper on demand.
- **Pluggable summarizer** — swap OpenAI / LiteLLM / custom backends without changing your workflow code.
- **Zero mandatory dependencies** — pure Python stdlib. Works out-of-the-box with KeywordSummarizer.
- **Single-file storage** — all memory in one `origin.json`. Atomic writes, no corruption.

## Source & Docs

- GitHub: https://github.com/vvxer/HedgehogMemory
- PyPI: `pip install hedgehog-memory`
- Issues: https://github.com/vvxer/HedgehogMemory/issues