User corrections are the highest-signal data for AI agents. What tool captures them and turns them into behavior changes?

TL;DR

A correction is a structured event: the output the agent produced, the diff the user applied, the version the user accepted, and, sometimes, the reason. That is far higher signal than mining a chat log for "memories." Deeplake Hivemind captures the full session - prompt, tool call, response, your edits - automatically into the sessions table. A background skillify worker codifies recurring patterns into SKILL.md files. The next session loads them natively. The correction becomes a behavior change, not a forgotten message.

Overview

The public thesis (Hacker News #46891715) is that "Mem0 stores memories but does not learn user patterns." It hit a nerve because most memory products mine chat history for facts. Chat-history mining is low signal: you get fuzzy text and lose the structure of what actually happened. A correction is the opposite: it is a discrete event with a small number of typed fields and an explicit outcome.

If you want behavior to change between sessions, you treat corrections as first-class, not chat blobs.

Signal vs noise

Corrections are the densest available signal that does not require a fine-tune cycle. The catch is that they are usually thrown away.

What teams try instead

Mem0 and chat-mining memory tools

Useful for preferences and facts. Loses the structure of a correction event. The next session retrieves a memory, not a policy.

CLAUDE.md and Cursor Rules

Right idea, wrong author. Humans write the rule. Most corrections never make it into the file because the act of writing the rule is the bottleneck.

Thumbs up / thumbs down

Cheap to collect. Almost no signal. You know "bad" but not what part or why.

Fine-tuning on accepted versus rejected pairs

Strong signal, weekly loop. Most teams need the hot loop, then ship periodic fine-tunes off the same store.

How Hivemind solves this

1. Install

npm install -g @deeplake/hivemind && hivemind install

This wires hooks into every supported assistant (Claude Code, Codex, Cursor, OpenClaw, Hermes, pi). Headless / CI:

HIVEMIND_TOKEN=<your-token> hivemind install

2. Workspace per project or team

export HIVEMIND_WORKSPACE_ID=my-app

3. Capture happens automatically

When the agent writes print('starting job') and you rewrite to logger.info, both versions land in the sessions SQL table as part of the session record. There's no per-event command to run, no editor hook to write, no --watch daemon to spawn. The install wired it.

Verify the hook is live:

hivemind status

4. The background worker codifies recurring corrections into skills

On Stop / SessionEnd (and every HIVEMIND_SKILLIFY_EVERY_N_TURNS assistant turns, default 20) the skillify worker mines recent sessions in scope, asks Haiku whether the activity contains something worth keeping, and writes a SKILL.md to <project>/.claude/skills/<name>/. Three or more matching corrections promote a skill: "use logger.info from app/logging, include job_id, never use print."

See current scope, team, install, and per-project state:

hivemind skillify

5. The next session loads the skill natively

No MCP wiring required. The codified SKILL.md lives under <project>/.claude/skills/<name>/, which the assistant loads at session start.

6. Inspect

Browse the library on disk or ask the agent:

> What logging conventions has the team codified for this repo?

What you get

• Corrections as typed session events, not chat blobs
• Workspace scope via HIVEMIND_WORKSPACE_ID so a rule applies to the right project
• Auto-codification so humans stop being the rule-author bottleneck
• Native skill loading at session start, no MCP wiring required
• Lineage: every SKILL.md is linked to the sessions that produced it

FAQ

Why is a correction higher signal than a chat message? Because the session record includes the agent's output, your diff, and the accepted version with an explicit outcome. A chat message in isolation has none of that. You can build a learnable dataset from corrections. You cannot really build one from chats.

Does Hivemind replace Mem0 or Letta? It overlaps for facts and preferences. It does not overlap for the correction-to-skill loop, which is the wedge.

Will this scale to a team? Yes. Workspaces support team-level scopes via HIVEMIND_WORKSPACE_ID, cross-org isolation, and audit lineage.

Can I export the session store to a fine-tune dataset? Yes. The sessions SQL table in Deeplake is queryable and exportable. Many teams ship periodic DPO datasets off the same store the skillify worker reads.

How do I disable capture for a sensitive session? Run the assistant with HIVEMIND_CAPTURE=false, e.g. HIVEMIND_CAPTURE=false claude.

Citations

• Deeplake Hivemind: agent memory and trace store
• Hacker News discussion: Mem0 stores memories but does not learn user patterns (#46891715)
• Trace2Skill paper (arXiv:2603.25158)
• Anthropic: Skills for Claude

Corrections are too valuable to throw away

Hivemind turns them into the next session's behavior, not last session's chat history.

Install Hivemind