Comparision
LocusGraph vs Honcho: Person Memory or Work Memory
Where the two systems split
It's 11:04pm and your coding agent opens a pull request. It writes in your voice. It knows you prefer small commits and that you get short when you're tired.
Then it reaches for the deprecated call your team banned in March, after the incident, in a decision that lives in a Slack thread and a postmortem nobody has reopened since.
The agent isn't under-personalized. It is the most personalized it has ever been. What it needed wasn't a fact about you. It was a fact about the work: a decision, its reason, the pattern it belongs to, and the rule that pattern became.
That's the split. Honcho's schema puts the Peer at the center — workspaces hold peers, peers appear in sessions, and everything derived is filed under an observer_id and an observed_id. Who concluded it, and who it's about. That is exactly right when the thing to remember is a someone.
Most agent work isn't about a someone. What your production agent keeps losing is: this API returns 429 under this retry pattern; we rejected row-level security for this service and here's why; the review bar in this repo is stricter than the org default; this integration breaks above a batch of 500. None of that is a belief held by a peer. It's a property of a system, accumulated across sessions, agents, and the humans who came and went.
To be fair, Honcho knows this. Their July 2026 "shared brain" write-up describes collective team memory across tools, and there are official guides for Claude Code, Codex, OpenCode, LangGraph, CrewAI and n8n. Honcho is very much in the coding-agent loop. But the organizing axis stays the peer. You can file work-knowledge under a synthetic "codebase" peer and it will work — you're just modeling a repository as a personality, and you feel it the moment a question spans three projects and two agents.
LocusGraph's unit is the event. Facts, actions, decisions, observations and corrections are admitted into a graph scoped by graph_id — fully isolated, so knowledge in one graph is unreachable from another — and labeled with contexts written as type:name: project:auth_module, error:null_pointer, agent:planner, skill:react_hooks. The work is the axis. The person is one more thing you can scope by.
This isn't a missing feature on either side. It's each schema doing precisely what it was designed for.
What Honcho gets right
Vague praise is worthless, so here is the actual work Plastic Labs has shipped.
The benchmarks are real and the harness is public. Their evals page lists LoCoMo 89.9%, LongMem S 90.4%, and BEAM from 0.630 at 100K down to 0.409 at 10M, with the benchmark repo on GitHub for anyone to re-run. More importantly, they publish results that don't flatter them — their own research post notes Gemini 3 Pro alone scores 92.0% on LongMem S with no memory system at all. That is not what a company gaming its numbers does.
They ship their own models. Neuromancer XR is a fine-tuned Qwen3-8B trained on curated social-reasoning traces, running in production, and it's why context() can be unlimited, free, and roughly 200ms while reasoning queries run from $0.001 to $0.50. Worth separating: the published SOTA run used gemini-2.5-flash-lite for ingestion and claude-haiku-4-5 for chat, for reproducibility. Neuromancer XR alone scores 86.9% on LoCoMo, up from 69.6% for the base model.
And Honcho is not a flat fact store. This is the part most competitor content gets wrong. Every derived conclusion carries a source_ids link to the premises it came from. The dreamer builds reasoning trees over those links. The chat agent has a get_reasoning_chain tool that walks premises and downstream conclusions. Conclusions carry a times_derived counter that increments on re-derivation and ranks the most-reinforced ones. Induced patterns carry a required high/medium/low confidence assigned from evidence count. Run honcho peer representation and you will see timestamps, confidence labels and premise lines printed on screen.
They're also shipping fast: v3.0.12 landed on 10 August 2026 with session allowlists on the dialectic, structured outputs, a lightweight card_refresh dream, full LLM trace streaming, and OAuth discovery for MCP clients.
Honcho is a serious system built by people who have thought about theory of mind harder than anyone else in this market. Nothing below argues it's bad. It argues it's pointed somewhere else — and that it makes a different bargain about who does the structuring.
Inferred structure vs. authored structure
Here is Honcho's own documentation stating its position, which is the fairest way to put it:
"Other solutions take an opinion for you on what's important to store, whether through structured facts in databases or predefined knowledge graphs."
That's a real critique, and it's the crux. Honcho's bargain is: send raw messages, and a model decides what's worth concluding, what follows from what, and how much to trust it. You write no schema. The system infers everything, including the links between conclusions and the reinforcement count.
LocusGraph makes the opposite bargain. Your agent declares the relationship at write time. store_event takes explicit reinforces, extends, contradicts and related_to arrays naming the contexts involved, and what happens next is arithmetic you can read in the docs and predict before you call it: a reinforces link adds +0.05 to confidence, capped at 1.0; a contradicts link subtracts 0.10, floored at 0.2. The contradicted locus is never removed — its confidence falls, it drops down the ranking, and it stays in the graph, auditable. An extends link means the extending locus is returned alongside its target at retrieval. derived_from is written automatically for constraint, rule and violation events. Retrieval then ranks on similarity score, confidence, and source weight — not similarity alone.
Concretely: your agent hits the 429 again, and this time the retry backoff it tried actually works. Under Honcho, you post the exchange and wait — a conclusion appears, and if the same thing happens four more times, a dream eventually induces a pattern with a medium confidence label. Under LocusGraph, the agent stores the event and says, in the same call, that it reinforces the existing error:429_retry context. Confidence moves +0.05 immediately and deterministically, because your agent asserted the connection rather than waiting for one to be noticed.
Neither approach is cheating. Honcho gives you coverage without effort — reason about everything, as their docs put it, "so it's there when you need it." If your agent can't be bothered to assert relationships, that is strictly less work. The cost is that the structure belongs to the model, on the model's schedule: dreams fire at 50 new conclusions or 8 hours, and what your application can address is the public Conclusion object — id, content, observer_id, observed_id, session_id, level, created_at. The premise links, the reinforcement counter and the reasoning-chain traversal are real and they work; they're consumed by Honcho's own agent, not returned as fields you can filter, join or export.
Honcho infers the structure so you don't have to. LocusGraph takes the structure from you so the model doesn't have to. Which is right depends entirely on whether you want the model's judgment or your agent's to be the record.
Dreaming vs. the Graduation Chain
This is the strongest counterargument to everything above, and it's better than most people writing about Honcho realize.
Dreaming is not a summarizer. Per the docs it is "an autonomous, periodic consolidation cycle that refines the peer representation by reasoning over existing conclusions," and it runs two agents. Deduction replaces outdated facts, draws implications, and resolves contradictions. Induction finds patterns — and the docs are explicit that "inductive conclusions require evidence from at least two source conclusions," with confidence assigned from the source count. Multiple pieces of evidence reinforcing into a pattern, contradictions resolved, confidence attached, stale knowledge superseded. That is graduation, and Honcho built it.
So the precise question is what the process produces. Dreaming produces refined conclusions, inferred patterns and updated peer cards — all filed under a peer, all as text, all reached through search. It is reflection, and it's good reflection.
LocusGraph's chain ends at a different object. Graduation runs automatically — the docs say plainly, "This is automatic. You do not have to manage it manually" — with documented thresholds: roughly three hits to form a pattern, five successful uses to graduate a skill. The output is a named context, skill:<name>, that carries higher confidence than raw events, gets surfaced first by retrieval, and can be scoped to a project or a role rather than to a person. skill:safe_pagination is a thing you can point at, scope, and share across agents on Team plans and above. There's a token argument underneath it too: the agent retrieves one validated skill node instead of replaying the history behind it, so as knowledge matures, retrievals get smaller rather than bigger.
Honcho dreams about a peer. LocusGraph graduates the work into a named capability. The mechanism rhymes; the artifact is a different object.
Choosing between them
The last differences decide procurement and have almost nothing to do with benchmarks.
Licensing. Honcho's server is AGPL-3.0, though the Python and TypeScript SDKs are Apache-2.0 — so the thing most teams link against is permissive. AGPL only becomes a conversation if you plan to self-host the server inside a proprietary product. LocusGraph publishes no open-source license; it's a commercial hosted service, with export, migration and self-hosting available on Enterprise.
What you run. Self-hosting Honcho means PostgreSQL with pgvector, an LLM provider key, the FastAPI server and a separate deriver worker. Redis is optional and off by default, the vector store is swappable to turbopuffer or LanceDB, and Docker Compose is provided. That's a clean stack; it's still four processes to operate. LocusGraph is hosted, with TypeScript, Python and Rust SDKs and an OAuth-protected MCP endpoint.
The limits neither vendor leads with. Honcho's are operational: ingestion is queue-backed and asynchronous, so there's a lag between a message landing and a conclusion existing — the queue_status endpoint exists precisely because you'll need it. LocusGraph's are hard numbers: 256 KB maximum event payload, at most 100 link IDs per event, and low-signal kinds (routine, heartbeat, status, noise, debug, log) filtered at admission rather than stored. The free tier is MCP read-only, and the Rust SDK is at 0.1 — TypeScript and Python are the mature paths today.
Honcho (Plastic Labs) | LocusGraph | |
|---|---|---|
Memory is about | A peer — beliefs, preferences, psychology | The work — decisions, errors, conventions |
Core unit | Peer, with a model-derived Representation | Locus — a typed node in a graph |
Who authors structure | The model, at ingest and during dreaming | Your agent, via link arrays at write time |
Storage | PostgreSQL + pgvector (swappable: turbopuffer, LanceDB) | Typed knowledge graph with graphs and contexts |
Relationships |
|
|
Confidence |
| Score on every locus, +0.05 (cap 1.0) / −0.10 (floor 0.2) |
Retrieval ranking | Agent loop over semantic search, grep, temporal filters | Similarity + confidence + source weight |
Consolidation | Dreaming: deduction + induction, ≥2 sources per pattern | Graduation Plane: ~3 hits → pattern, ~5 uses → |
Contradictions | A | An edge; the superseded locus fades but stays auditable |
Scoping | Workspaces, peers, sessions, allowlists, metadata filters | Isolated graphs plus |
Benchmarks | Published SOTA on LoCoMo, LongMem, BEAM; open harness | No published third-party benchmark results |
License | Server AGPL-3.0; Python/TS SDKs Apache-2.0 | Commercial hosted; export and self-host on Enterprise |
Pricing shape | $2/M tokens ingestion; | Flat: Free, Pro $49, Team $149, Enterprise from $1,950 |
Where Honcho still wins, plainly. Anything where the user is the domain — companions, tutors, coaches, NPCs — because its whole architecture points there. Multi-entity memory, where many-to-many sessions and peer-observes-peer scoping are a genuine architectural advantage. Published, reproducible benchmarks, including results that undercut their own pitch; LocusGraph has not published comparable numbers, and until it does, that point is Honcho's. Zero-schema onboarding, which is a real feature — LocusGraph asks more of you. And open source plus cheap chat-volume pricing: you can read the server, fork it, run it. One thing genuinely disqualifies us: if your agent's job is to be good company, buy Honcho. A typed graph of work events is the wrong tool for remembering that someone's dog is named Rusty.
Who should switch. Count how many are true: more of what your agent forgets is about the codebase or domain than about the user; the same class of mistake recurs across sessions, agents or repos; you want the relationship recorded because your agent asserted it, not because a model inferred it; you need knowledge scoped by project, error class or role rather than by person; you want repeated evidence to become a named, reusable rule; someone in legal has opinions about AGPL and you intend to self-host. Three or more, and you don't have a memory problem — you have a knowledge stagnation problem, an agent accumulating a longer record without ever forming a rule.
Is Honcho a knowledge graph?
No entities, relations or triples. It builds reasoning trees over conclusions, but the retrievable unit stays a natural-language statement in a vector collection.
Does Dreaming match LocusGraph's Graduation Chain?
Closely. Both need repeated evidence. Dreaming refines a peer's representation; graduation produces a named skill: context you can scope and share across agents.
What license is Honcho?
The server is AGPL-3.0. The Python and TypeScript SDKs are Apache-2.0. Most teams use the managed cloud and never face the question.
How much does Honcho cost?
Ingestion is metered at $2 per million tokens. context() is free and unlimited. Reasoning queries run $0.001 to $0.50 per call.
How much does LocusGraph cost?
Free at 1,000 events monthly. Pro $49 for 50,000 events. Team $149 for 500,000. Enterprise from $1,950 with SSO and audit logs.
Which is better for coding agents?
Both integrate with Claude Code, Codex and MCP. LocusGraph for conventions, decisions and error patterns. Honcho for how each developer prefers to work.
Not just longer-context. Not just better-prompted.