The fundamental problem with per-harness memory is not storage — it is identity. Cursor does not know what Claude Code learned. Codex does not know what Cursor learned. Each tool starts fresh every session.

honeycomb solves this with a single daemon bound to 127.0.0.1:3850. Every harness — all six of them — is a thin client that talks to the same store over loopback HTTP. One write from Claude Code is readable by Cursor two minutes later.

Why loopback-only #

Binding to 127.0.0.1 — not 0.0.0.0 — means the daemon is unreachable from outside your machine. No network interface, no firewall rule, no accidental exposure. The memory store is local and private by design.

This constraint also eliminates an entire class of auth problems. You do not need API keys or tokens to access the daemon from your local harnesses — the loopback binding is the auth. Any process on your machine can reach it; nothing outside can.

The thin-client contract #

typescript

// Every harness adapter implements the same minimal interface.
interface HarnessClient {
  /** Called before each turn — injects relevant memories. */
  recall(query: string, scope: MemoryScope): Promise<MemoryHit[]>;

  /** Called after each turn — captures the turn as a new memory candidate. */
  capture(turn: TurnCapture): Promise<void>;

  /** Health check — returns false if the daemon is unreachable. */
  ping(): Promise<boolean>;
}

// If ping() returns false, the harness runs without memory injection.
// No errors surfaced to the user — silent degradation.

Silent degradation is important. If your daemon is not running — you just rebooted, you are on a plane, the process crashed — the harness should not block or error. It just skips memory injection. You get the same experience as any other session-only assistant.

Scope: personal, team, org #

The memory store has three scopes. Personal is private to you — your conventions, your preferences, your notes to future-you. Team is shared across everyone running honeycomb in the same workspace (resolved via the team sync endpoint). Org is read-only from the org ruleset — policies, standards, mandated patterns.

Team and org scopes require a sync endpoint configured in ~/.honeycomb/config.json. Personal scope works offline with no config.

The six harnesses today #

Claude Code, Cursor, Codex, Hermes, pi, and OpenClaw each have a thin client adapter. The adapters live in the harnesses/ directory of the daemon package. They share no code with each other — each adapter is purpose-built for its host — but they all talk to the same REST surface at 127.0.0.1:3850.

Adding a seventh harness means writing one new adapter. The store, the Dreaming loop, the skillify miner, the recall query engine — none of that changes.

What cross-harness recall looks like #

bash

# 9:00 a.m. — Claude Code session
> "we should use the edge function for auth refresh"
# honeycomb captures: "auth refresh via edge function" — session:4c19 — score 0.88

# 3:00 p.m. — Cursor session, different window
> "how should we handle token refresh?"
# honeycomb injects: auth refresh via edge function · session:4c19 · 0.88
# Cursor has the context. No copy-paste, no re-explanation.

That is the promise. One daemon, one store, six windows. What one agent learns, every agent recalls.