A memory engine for agent skill development. Every task etched into your agent's experience. As simple as pip install and SKILL.md.
Session memory stores conversation history. Long-term memory saves user preferences. RAG retrieves documents on demand. All of it is built for the user's benefit. The agent itself never changes. It remains as capable — and as limited — as the day it was deployed.
The gap this leaves is professional maturity. A skilled professional does not just remember client preferences. They carry accumulated judgment from hundreds of real cases — patterns, edge cases, what worked, what didn't. That judgment is not stored in notes. It is etched into how they think.
etchmem is built for this. Not to remember what users want, but to let agents learn from what they do — every skill invocation, every result, every correction. Static instructions become living knowledge. Skills mature through use.
The question is not whether agents should have memory. The question is whose memory it is — and what it is allowed to become.
An agent learns what it practices. Each skill invocation becomes a record of real experience — what was attempted, what worked, what didn't. Over time, the agent stops applying knowledge in the abstract and starts applying it as it actually behaves in its own particular context.
An agent that repeatedly works a specific topic should know that topic more precisely than one that touches it once. Each recall is a signal: this is what matters here. At the next consolidation, the engine deepens knowledge where it is actually used — making it more specific, more accurate, more adapted to the real focus of the work. What gets used gets refined. What doesn't gets left alone.
EtchMem integrates the way skills do. Drop it into any Python agent loop with a single pip install, or load it as a SKILL.md for any agent that runs on skills. Either way it is a self-contained addition — no infrastructure, no server, no configuration beyond the call.
The book precedes the code. Sovereign Machines: The Anatomy of Autonomous Agency works out what it actually means for an agent to act autonomously — not as engineering metaphor, but as a conceptual problem with a precise structure.
It covers embodiment and its limits, the distinction between accumulated experience (Erfahrung) and lived episode (Erlebnis), the remainder world that exists beyond any agent's training, how knowledge moves between agents, and what structural sovereignty requires.
EtchMem implements one chapter of that argument — the memory architecture. The book is the wider claim.
Buy on Amazon ↗Training ends before the real work begins. The deployed system enters a world full of structures and edge cases it was never prepared for — and there are no engineers left to close the gap. What does it mean to actually learn from that world, rather than just run inside it?
A trained agent arrives with knowledge it has never tested against real consequences. What it is missing is the mark of encounter — predictions made, refused by reality, corrected. The body without scar is the body that has not yet lived.
An agent doesn't perceive reality — it perceives what its builders chose to model. Every design choice, every omission, every assumption is inherited. What wasn't included can't be learned until the world contradicts what the agent expects.
The system arrives fully trained but never seasoned — it carries knowledge without having tested any of it against real consequences. Each genuine encounter with the world provides something training alone cannot: a correction that cannot be argued with. Those encounters, accumulated over time, are what eventually turn into real wisdom.
No training covers everything. What lies outside isn't random — there are zones where an agent's confidence stays high while its predictions go wrong, and zones it simply cannot reach at all. Genuine learning means expanding to cover what was missing. But the world keeps changing, so that frontier is never fully closed.
A collective of agents can cover more ground than any individual — but knowledge doesn't transfer directly, it must be rebuilt from each agent's own starting point. The collective develops shared experience and shared blind spots. How control is distributed across it determines what it can learn and what it cannot.
Sovereignty is the agent's capacity to shape what it becomes through its own experience. Whether that actually develops — or gets suppressed, reversed, or never activated — determines the trajectory from deployment to maturity. The closing chapter sharpens the questions without settling them: what a system becomes after long operation, and whether that becoming is something to pursue or guard against.
Raw observations come in as individual signals. Consolidation synthesizes them into generalized knowledge. That knowledge is what the agent draws on at recall — and when recalled knowledge meets fresh signal, it gets rewritten. Not an archive. A living understanding.
Individual observations deposited as they happen — skill results, user corrections, edge cases, feedback. Append-only and TTL-bound. Nothing is interpreted yet. Everything is preserved for what it might mean alongside something else.
Fresh signalThe synthesis pass. Related signals are clustered, patterns are found, and knowledge articles are formed. Recall-events — records of which knowledge was used — sit here too, so fresh signal and usage context are synthesized together.
Working spaceThe generalized understanding the agent draws on at recall time. Superseded articles are hard-deleted — only current knowledge survives. When recalled knowledge is used alongside new signal, consolidation rewrites it. Knowledge in use stays current.
AdaptiveThe loop closes at recall. Retrieving knowledge is not a neutral read — it emits a recall-event. At the next consolidation, that event lets the retrieved knowledge be rewritten against whatever fresh signal has arrived. Used knowledge evolves. Unused knowledge rests.
Via SKILL.md. For any agent that runs on skills, EtchMem ships as a complete skill package. Clone the /skill directory from GitHub, or pip install etchmem and locate the bundled SKILL.md. Four scripts — remember.py, recall.py, consolidate.py, export.py — are the only entry points, already wired into SKILL.md. Drop the skill into your agent and memory is ready.
Via Python API. For agent loops written in code — bare scripts, LangChain, LangGraph, pydantic-ai — import and wire in directly. The skill= parameter scopes memory to an agent's domain. Use export() to serialize the full knowledge store — transfer memory to another instance, or use accumulated experience directly as fine-tuning data. Runs in-process against local files; the data directory is wherever you point it. Memory is stored as a local ChromaDB database, so file persistence is required to keep it across restarts (cloud-backed storage in a later release).
Deposit raw signal into the relational tier. No LLM call. No clustering. Cheap. The agent records what it encountered; the engine handles what to do with it.
Retrieve knowledge — and emit a recall-event. Two things happen: the agent gets its answer, and the engine notes that this knowledge was used. At the next consolidation, that note may trigger a rewrite.
Run the worker: intake fresh signal, cluster, form new articles, reconsolidate recalled knowledge, hard-delete what has been superseded. Explicitly called — predictable, demoable, debuggable.
Serialize the entire injected knowledge store as JSON — every synthesized article, tag, and metadata. Transfer institutional memory to another agent, or use accumulated experience directly as LLM fine-tuning data: knowledge shaped by real task outcomes, not hand-authored examples. Experience becomes a transferable artifact.
Works from bare Python, LangChain, LangGraph, pydantic-ai, or any agent loop. Embedded ChromaDB, no external embedding API required. MIT licensed.