hmem — Humanlike Memory for AI Agents

Your AI forgets everything between sessions. hmem fixes that.

One load_project() call. ~3000 tokens. Your agent knows everything important about a project — every past mistake, every decision, every open task — across sessions, devices, and AI providers. No setup per conversation. No "let me re-read the codebase." It just remembers.

AI agent? Skip this file. Read AGENT_SETUP.md — written for you, not for humans.

Naming note (v8.0): This package was briefly published as its-over-9k (1.x). It is now hmem again — pure memory framework, nothing else. The its-over-9k name lives on as a separate project: the o9k token-efficiency meta-framework, which combines skills/plugins like this one. Related: TIM — hmem's next-generation successor (hypergraph memory, CRDT sync).

What This Is

hmem is not a note-taking plugin. It's a memory framework for AI agents — a complete infrastructure layer for persistent, portable, token-efficient knowledge that survives session boundaries, device switches, and provider changes.

Four core guarantees:

The Problem

Every AI session starts from zero. Your agent asks the same questions, makes the same mistakes, contradicts last week's decisions, and wastes 50k tokens loading context it already processed yesterday.

You've tried workarounds — CLAUDE.md files, custom prompts, manually pasting context. They don't scale. You have 10 projects. You switch between 3 devices. You use different AI tools.

The Solution

You:    "Load project"
Agent:  [calls load_project("P0048") — 3000 tokens]
Agent:  "v1.2.9, TypeScript/SQLite/npm. 3 open bugs, 8 roadmap items.
         Last session: rebrand complete, rename_id bug fixed (89 changes).
         Next: O-Entry Auto-Purge. What's the focus today?"

That's it. 3000 tokens for a complete project briefing. The agent knows the stack, the architecture, the open bugs, the recent decisions, and exactly where you left off — even if "you" was a different AI on a different machine yesterday.

How It Works

Level 1  ──  One-line summary          (always loaded — ~5k tokens for 300+ entries)
  Level 2  ──  Paragraph detail        (loaded on demand)
     Level 3  ──  Full context          (loaded on demand)
      Level 4  ──  Extended detail      (loaded on demand)
        Level 5  ──  Raw/verbatim data  (loaded on demand)

At session start, the agent loads Level 1 summaries — one line per memory. When it needs detail, it drills down. Your 300-entry memory costs 5k tokens to overview. A single project costs ~3000 tokens.

Nothing is summarized away. Level 1 is a compressed view, but Levels 2–5 hold the complete original text, word for word, accessible on demand.

Framework Features

Automatic Session Memory

Every conversation is recorded automatically. No "save your work" prompts. No manual checkpoints.

You type  →  Agent responds  →  Stop hook fires  →  Exchange saved to O-entry
                                                   →  Linked to active project
                                                   →  Haiku auto-titles the session

Switch projects mid-session? The O-entry switches too. Start a new session on a different device? The next agent sees every exchange from every device — the conversation never dies.

Haiku Background Checkpoints

Every N exchanges (configurable, default 5), a Haiku subagent wakes up in the background. It reads the recent conversation, extracts lessons learned, errors encountered, and decisions made, then writes them to long-term memory — with full MCP tool access. Your main agent is never interrupted.

The checkpoint also writes a handoff note to the project: "Here's what was done, here's what's in progress, here's the next step." The next agent — on any device, any provider — picks up exactly where you left off.

Project-Based, Not Session-Based

Sessions are meaningless. Projects are everything.

• O-entries are linked to the active project, not the session
• Checkpoint counters count project exchanges, not session messages
• load_project shows recent conversations with full context — across all devices

Skills System

hmem ships with a complete skills layer — structured behavior files that agents load on demand. Skills define how an agent should do something (debug, write memory, curate entries, handle a session start) — separate from memory, separate from prompts.

npx hmem update-skills    # Pull latest skills to your AI tool's skill directory

Skills are versioned and updated independently. Your agents get smarter without reinstalling. 21 skills ship by default:

Company Memory

Beyond personal memory, agents can maintain a shared company store — a separate company.hmem that multiple agents and team members can read from. Personal and company memory coexist; agents query both simultaneously.

import { openCompanyMemory } from 'hmem';
const store = openCompanyMemory('/path/to/project');

Embeddable SDK

hmem ships as a fully documented TypeScript SDK — import HmemStore directly into your own agents, tools, or automation pipelines:

import {
  HmemStore, openCompanyMemory, resolveHmemPath,
  loadHmemConfig, saveHmemConfig, DEFAULT_CONFIG, DEFAULT_PREFIXES, formatPrefixList,
  searchMemory,
} from 'hmem';
import type {
  AgentRole, MemoryEntry, MemoryNode, HmemConfig,
  SearchResult, SearchOptions, SearchScope,
} from 'hmem';

const store = new HmemStore('/path/to/agent.hmem');
const results = searchMemory('/path/to/project', 'auth token bug', { maxResults: 5 });

MCP Tools

hmem ships two MCP servers:

• hmem (daily-use, 13 tools) — read, write, search, project lifecycle.
• hmem-curate (maintenance, 11 tools) — bulk edits, schema migrations, backup/restore. Activate only when curating.

hmem — daily-use server (13)

hmem-curate — maintenance server (11)