Local-first runtime
A SQLite-backed memory service with no mandatory hosted control plane.
PORTABLE AI AGENT MEMORY
Your agents should not have to forget their work.
HotMem is a portable, local-first memory layer for AI agents and digital organizations. Capture the facts, decisions, project context, and provenance that make work useful—then search, snapshot, verify, restore, and move that memory between compatible HotMem runtimes.
CONTEXT SHOULD CONTINUE
Make context durable instead of rebuilding it.
Knowledge work creates more than chat history. It creates requirements, choices, facts, references, project state, and operational context. When that knowledge is trapped inside a single session or platform, the next person or agent starts with an incomplete picture and teams waste time reconstructing what already happened.
HotMem makes useful context explicit and operable. Applications and agents can store scoped memory, retrieve the most relevant facts, inspect provenance, create portable snapshots, and hydrate validated memory into a clean runtime. The result is a reproducible working brain that survives restarts, handoffs, project boundaries, and infrastructure changes.
A SIMPLE, AUDITABLE WORKFLOW
Capture. Retrieve. Snapshot. Verify. Hydrate. Continue.
Capture
An application or agent writes facts, decisions, observations, and project context through a local HTTP API, Python client, TypeScript client, CLI, or MCP integration. HotMem stores runtime memory in SQLite and keeps the core workflow local.
Retrieve
Hybrid keyword and vector ranking surfaces relevant memory as LLM-ready message objects, retaining the identifiers, scores, and provenance needed for inspection.
Snapshot and verify
Export canonical JSONL or a versioned Snapshot v2 directory. Snapshot v2 includes a manifest and SHA-256 checksums so a recipient can detect corruption before hydration.
Hydrate and continue
A compatible HotMem runtime validates and loads the snapshot. Replaying the same snapshot is designed not to create duplicate logical memories, making restore and repeated delivery safer and more predictable.
BUILT FOR PORTABILITY
A lean memory layer with durable artifacts.
Portable JSONL
A plain, inspectable record stream that can be versioned, transformed, archived, and transferred.
Verified snapshots
Snapshot v2 packages use versioned manifests and SHA-256 integrity checks.
Fast hybrid retrieval
Vector, keyword, and importance signals combine to return useful context.
Agent-operable interfaces
HTTP, Python, TypeScript, CLI, and MCP surfaces let agents add, search, snapshot, and restore scoped memory.
Provenance that travels
Source identity, hashes, timestamps, file references, and lifecycle data can survive movement.
HotMem also supports legacy JSONL and JSONL.GZ snapshots, a one-command Mem0 SQLite history importer, and integrations for LangChain, CrewAI, AutoGen, Pydantic AI, and Hermes Agent. Its deterministic offline embedding path does not require a transformer model, GPU, API key, or remote vector store.
THE PORTABLE COMPANY BRAIN
Build a reproducible digital organization brain on open artifacts.
A digital organization brain is the governed context that helps people and agents continue useful work: what an organization knows, why decisions were made, which sources support a fact, and what changed over time.
HotMem keeps that brain portable rather than platform-bound. SQLite is an efficient local runtime. JSONL is the canonical interchange stream. A versioned manifest adds integrity, compatibility, and package identity. External indexes, embedding providers, agent frameworks, and transport layers can evolve without making the durable memory artifact opaque or proprietary.
That gives teams a practical path to capture a known state, reproduce it in a compatible environment, verify what arrived, and continue without context archaeology.
FOR AGENTS, TEAMS, AND TOOLS
Where HotMem fits.
Enterprise and company memory
Create scoped, auditable working memory for engineering, finance, operations, compliance, sales, and internal knowledge workflows.
Coding-agent handoffs
Carry requirements, decisions, facts, and file provenance into a clean HotMem runtime when a repository, machine, or supported agent harness changes.
Creative and research continuity
Retain references, constraints, prior choices, and evolving ideas across long-running investigations and creative projects.
Personal local-first memory
Run a durable memory sidecar on ordinary writable storage and inspect the portable records yourself.
PORTABILITY IS A PRODUCT REQUIREMENT
Memory must be able to travel.
Retrieval quality matters. But operational memory also needs an answer to harder questions: Can it be exported in a documented, inspectable format? Can a clean target reproduce the useful state? Can integrity be checked before import? Does provenance survive movement? Is repeated hydration safe? Can an agent manage the lifecycle through clear interfaces?
HotMem treats those questions as first-class product requirements. Its open JSONL interchange path, verified snapshots, local runtime, and explicit adapters provide a memory layer that can be moved and governed rather than merely queried.
HONEST ABOUT WHAT SHIPS TODAY
From verified clones to connected organization brains.
HotMem's north star is an open standard for connected digital organization brains: snapshot a workspace, transfer a verified package through a trusted path, hydrate it in a supported target, and continue work with relevant context intact.
Today, HotMem supports local runtime memory, snapshots, hydration, integrity verification, provenance, and documented integrations. Formal interchange packages, broader platform migration adapters, incremental synchronization, signing, encryption, secure transport, and deliberate multi-writer semantics are staged roadmap work. HotMem distinguishes shipped capability from direction so teams can evaluate it on reproducible guarantees rather than slogans.
START LOCALLY
Give an agent a durable memory mount.
pip install hotmem
hotmem serve --mount ./hotmemFollow the documentation to add memory, search it, create a snapshot, and hydrate a clean runtime.
FREQUENTLY ASKED QUESTIONS
HotMem, answered.
What is HotMem?
HotMem is a local-first memory sidecar for AI agents and applications. It stores queryable working memory in SQLite and provides portable JSONL and verified snapshot workflows for backup, restore, handoff, and migration between compatible HotMem runtimes.
Does HotMem require a cloud service or vector database?
No. The core runtime works locally and does not require a hosted vector database, API key, GPU, or mandatory control plane. Teams can add external services and adapters around the portable core when their deployment requires them.
What is the HotMem JSONL format used for?
JSONL is HotMem's canonical portable record stream. It is human-inspectable, streamable, versionable, and easy to validate or transform. HotMem also supports compressed JSONL.GZ and Snapshot v2 packages with manifests and file checksums.
Can HotMem move memory between Claude, Codex, ChatGPT, or other agent platforms?
HotMem provides the portable memory foundation and tested interfaces needed for migration, but each external platform boundary requires a supported adapter or importer. Universal one-click migration across every named platform is a product direction, not a shipped claim today.
Is HotMem encrypted?
HotMem currently provides Snapshot v2 integrity verification through SHA-256 checksums. Encryption, signing, identity, authorization, and secure transport are roadmap capabilities and should not be represented as current guarantees.
How is HotMem different from hosted agent-memory services?
HotMem prioritizes a lean local runtime, portable open artifacts, verified restore, provenance, and agent-operable lifecycle controls. Its focus is making useful memory reproducible and able to travel across compatible environments.