/ ml vs Honcho

A frontier AI memory system vs. background "dreaming" LLM workers and query-time /chat synthesis.

/ ml Frontier AI Memory System

✓94.5% LoCoMo & 80.8% DolphinBench (600 tasks) with zero query-time LLM synthesis
✓0.86 ms P50 recall & synchronous <10 ms writes (immediately searchable)
✓$45.90 DolphinBench run cost (3.1× cheaper) & scales to 77.2% at 10M tokens

Honcho (Plastic Labs) Query-Time /chat LLM + Async Dreaming

✕89.0% LoCoMo (requires query-time /chat LLM synthesis) & 68.5% DolphinBench (+2.8 pts over no-memory)
✕1,000–5,000 ms (~2,500 ms P50) blocking recall latency & async background "dreaming" lag
✕$142.85 DolphinBench run cost (3.1× higher LLM spend) & 94.6s P95 task latency

LoCoMo Accuracy +5.5 pts

/ ml 94.5%

Honcho 89.0%

0.86 ms lookup vs /chat LLM synthesis

Recall P50 Latency 2,906× Faster

/ ml 0.86 ms

Honcho 2,500 ms

Sub-ms recall vs 1–5s query-time LLM

DolphinBench (600) +12.3 pts

/ ml 80.8%

Honcho 68.5%

No-memory baseline is 65.7%

Dolphin 600 Cost 3.1× Cheaper

/ ml $45.90

Honcho $142.85

Zero memory-side LLM token burn

How / ml outperforms Honcho across accuracy, latency, and cost

Evaluated across LoCoMo (ACL 2024), the independent 600-task DolphinBench Official Leaderboard, and LongMemEval-V2.

LoCoMo & DolphinBench (600 Tasks) · Higher is Better

Memory & Agent Task Accuracy

+12.3 pts on DolphinBench

/ ml LoCoMo Top-20

94.5%

Honcho LoCoMo (/chat LLM)

89.0%

/ ml DolphinBench (600)

80.8%

Honcho DolphinBench (600)

68.5%

Built-in Baseline No External Memory

65.7%

/ ml BEAM 10M Scale

77.2%

Honcho BEAM 10M Scale

N/A

Recall P50 · Task Latency · Run Cost · Lower is Better

Latency & 600-Task Run Cost

2,906× Faster · 3.1× Cheaper

/ ml Recall P50

0.86 ms

Honcho Recall P50 (/chat)

2,500 ms

/ ml Dolphin Task P50

33.9 s

Honcho Dolphin Task P50

44.7 s

Honcho Dolphin Tail P95

94.6 s

/ ml Dolphin 600 Cost

$45.90

Honcho Dolphin 600 Cost

$142.85

Why query-time dialectic LLM calls and background "dreaming" slow your agents down

Honcho (Plastic Labs) approaches memory by running an LLM at write time ("dreaming") and another LLM at read time (/chat dialectic synthesis). Here is why teams switch to / ml.

Honcho invokes an LLM on every memory query (~2,500 ms P50)

/ ml 0.86 ms Recall · 94.5% LoCoMo

Honcho ~2,500 ms (/chat LLM) · 89.0% LoCoMo

Honcho's 89.0% LoCoMo benchmark does not measure fast memory lookup—it calls Honcho's dialectic /chat endpoint, which runs an LLM inference pass at query time to synthesize an answer before your agent even begins its turn. That adds 1–5 seconds (~2,500 ms P50) of blocking latency on every single recall.

/ ml Advantage: Recalls exact multi-hop context in 0.86 ms (2,906× faster) with zero query-time LLM calls—scoring 94.5% (+5.5 pts).

3.1× higher cost on DolphinBench for barely-above-baseline accuracy

/ ml 80.8% Accuracy · $45.90 Cost

Honcho 68.5% Accuracy · $142.85 Cost

On the independent 600-task DolphinBench suite, Honcho's background "dreaming" workers and query-time synthesis push total run cost to $142.85 while achieving only 68.5% accuracy (just +2.8 pts above the 65.7% Built-in no-memory baseline) and 94.6s P95 tail latency.

/ ml Advantage: Achieves 80.8% accuracy (+12.3 pts over Honcho) on DolphinBench at just $45.90 total cost (3.1× cheaper) and 33.9s median task latency.

Built for chat persona deductions—blind to codebases & 10M scale

/ ml 77.2% @ 10M · Synchronous <10 ms

Honcho Async Dreaming Queue · No 10M / AST

Honcho's "theory-of-mind" peer cards are designed to summarize user psychology in chat apps. Because it relies on asynchronous background "dreaming" queues, facts written on Turn 1 aren't deterministically indexed on Turn 2, and it lacks codebase symbol/call-graph indexing or 10M-token scaling.

/ ml Advantage: Synchronous state updates in <10 ms across conversational facts, temporal state changes, and AST/call-graph code structures—holding 77.2% at 10M tokens.

Complete Head-to-Head Breakdown: / ml vs. Honcho

Every benchmark, latency percentile, and billing line-item side by side.

Dimension	Honcho (Plastic Labs)	/ ml	Your Advantage with / ml
Core Architecture	Background "Dreaming" LLMs + Query-Time /chat LLM	Frontier AI Memory System	Zero LLM calls on write or recall; deterministic state
LoCoMo Accuracy	89.0% (via query-time /chat LLM synthesis)	94.5% SOTA (Top-20 Retrieval)	+5.5 pts higher accuracy without query-time LLM synthesis
DolphinBench (600 Tasks)	68.5% (+2.8 pts over no-memory baseline)	80.8% (#1 SOTA · +15.1 pts over baseline)	+12.3 pts higher real-world agent task accuracy
DolphinBench Total Run Cost	$142.85 (600 tasks)	$45.90 (600 tasks)	68% lower cost (3.1× cheaper)
Recall Latency (P50)	~2,500 ms (1–5s query-time LLM synthesis)	0.86 ms	2,906× faster recall (sub-millisecond)
Agent Task Latency (P50 / P95)	44.7 s P50 · 94.6 s P95	33.9 s P50	24% faster median task completion
Write Availability	Async background "dreaming" worker queue	Synchronous (<10 ms)	Memories are searchable immediately on the next turn
Codebase & Symbol Graphs	— Conversational peer cards only	Full AST Symbol, Call-Graph & Bug Recall	Unified memory for both chat agents and coding harnesses

Replace Honcho with / ml in minutes

Eliminate slow session.chat() synthesis waits and background dreaming lag with synchronous .add() and 0.86 ms .search().

Swap Honcho Dialectic Calls for 0.86 ms Stateful Recall

Instead of waiting 1–5 seconds for honcho.apps.users.sessions.chat() to run an LLM synthesis pass before your agent can respond, query / ml directly in 0.86 ms.

agent.py — Honcho to / ml Migration Diff Python / TypeScript

-from honcho import Honcho-honcho = Honcho(app_name="my-agent")+from slashml import Memory+mem = Memory(api_key="<SLASHML_API_KEY>") -# Honcho queues background "dreaming" workers & waits 1-5s on /chat synthesis-honcho.apps.users.sessions.messages.create(session_id=s_id, user_id=u_id, content=msg)-context = honcho.apps.users.sessions.chat(session_id=s_id, user_id=u_id, queries=[query])+# / ml updates state synchronously in milliseconds and recalls in 0.86 ms:+mem.add(msg, user_id=u_id, metadata={"session_id": s_id})+context = mem.search(query, user_id=u_id)

Import Existing Honcho Sessions & Peer Representations

Stream your existing Honcho session histories and user representations directly into / ml with instant synchronous indexing and zero external LLM fees.

Import Honcho Sessions into / ml CLI / Python

$# Export & ingest existing Honcho sessions into / ml:+npx -y @slashml/memory migrate --from honcho --honcho-key $HONCHO_API_KEY --api-key <SLASHML_API_KEY>

Ready for 0.86 ms recall and 80.8% DolphinBench accuracy?

Start free with 10,000 ingests + 1,000 retrievals/month and zero feature locks, or contact our team for custom enterprise migration support.

Start Free & Get API Key Contact Engineering Support