Persistent memory engine for AI agents. Memories decay, consolidate, and get queried at microsecond speed via a bit-sliced bitmap index.
docker run -p 8765:8765 -v ferricula-data:/data kord/ferricula
In a conventional memory system, something is either stored or it isn't. Retrieval is lookup — you ask, it returns, nothing changes. The record is inert.
A thermodynamic memory system treats memory as a physical substance with energy. Every record holds a charge — a fidelity score from 0.0 to 1.0. That charge dissipates over time unless work is done to maintain it. Recall is that work: it re-energizes the record and tightens its decay curve, making future loss slower. Neglect does the opposite — the decay rate drifts wider, and eventually the record crosses below a survival gate and transitions state.
The system also has temperature, not just individual memories. In Ferricula that's cognitive_heat on the agent identity. Rapid querying drives the temperature up. Past a ceiling the gates close — not to protect records, but to protect the agent from a recall feedback loop where it keeps pulling the same hot memories and drowning out everything else. The system cools passively and opens again.
The third property is phase transition. Memories move through states: active, forgiven, archived. A memory promoted to keystone reaches a zero-entropy crystalline state — it stops decaying entirely. That's the dream cycle acting as an annealing pass. The metaphor isn't decorative — the math underneath is literally exponential decay with variable rate constants, system-level thermal load, and phase transitions.
Every memory carries a fidelity score. Frequently accessed memories decay more slowly — recall tightens the decay curve, preserving what the agent returns to. The engine also tracks cognitive heat per agent: rapid recall accumulates heat, and when the Fortune gate is active, the engine stops surfacing memories until the agent cools.
An optional periodic process that consolidates memories into permanent keystones. Dream cycles cluster similar memories, discover semantic structure, and promote what has earned permanence — keystoned memories stop decaying entirely. Dreaming also cools cognitive heat: if rapid recall has driven the agent's temperature up, a dream cycle lets it dissipate. The balance is yours to tune — or let your agents tune it.
Each agent writes into its own named channel. Memory queries are scoped to that channel — agents don't see each other's context. Logical isolation for fleet deployments.
Memory state is written to durable storage. Agents rehydrate their context on startup. Long-running workloads accumulate genuine institutional memory over time.
The query engine is built on bit-sliced RoaringBitmaps. Tag intersections, channel scans, and fidelity range filters resolve in microseconds regardless of memory count. BM25, vector, and graph search run in parallel against the same index.
Ferricula exposes a SQL-style query API. SELECT, WHERE, tag filtering with tag_jaccard() similarity scoring. Agents and external tools query memory with the same expressive syntax you'd use on any structured store.
Consolidation builds a semantic graph over stored memories. Edges are discovered automatically between related memories during dream cycles. Graph traversal is a first-class query mode — follow associations the way memory actually works.
Ferricula ships as an MCP server. Claude Code users can add it as a memory backend today — persistent context across sessions, semantic search over past work, and agent identity that survives restarts.