Honcho
A different axis from Orectic and Penumbra. Where they build typed structure about your business, Honcho builds typed structure about the peers your agent talks to. Same architectural pattern, different subject — and the only one of the three with a direct plug-in path into your existing OpenClaw/Hermes/Claude Code stack.
Memory that reasons
Honcho is a memory system for stateful agents. Every message you write to it triggers reasoning by a custom model (Neuromancer). Two API calls do the work: context() gives you curated state at every turn, .chat() runs on-demand reasoning at five priced tiers. Continual learning, not just store-and-retrieve.
Explore this profile
Peers, sessions, and two API calls
Four primitives cover the surface. Two are containers (Peers and Sessions), two are actions (writing a Message triggers reasoning; reading via context() or .chat() returns curated state).
Peer
Any entity Honcho can model — a user, an agent, an NPC, a group. Not just user-vs-assistant. Peers have scoped perspectives and can be added to sessions freely.
Session
A container for messages between peers. Sessions can include any combination — one user + one agent, groups, subagent trees. Reasoning is scoped to the session but informed by everything Honcho has learned about the peers in it.
HONCHO — HOW A MESSAGE FLOWS
your app Honcho
──────── ──────
│
│ session.add_message("Alex", "...")
├────────────────────────────────────────▶ ┌───────────────────────┐
│ │ 1. store + index │
│ │ Message → session │
│ └───────────┬───────────┘
│ │
│ ▼
│ ┌───────────────────────┐
│ │ 2. Neuromancer │
│ │ reasoning fires │
│ │ (custom model) │
│ └───────────┬───────────┘
│ │
│ ▼
│ ┌───────────────────────┐
│ session.context() │ 3. state updated │
│◀─────────────────────────────────────────│ per-peer + session │
│ curated summary + relevant history └───────────────────────┘
│ ~200ms · token-budgeted
│
│
│ peer.chat("What are Alex's recurring concerns?", level="high")
├────────────────────────────────────────▶ ┌───────────────────────┐
│ │ on-demand reasoning │
│◀─────────────────────────────────────────│ 5 priced tiers │
│ │ $0.001 → $0.50 │
│ └───────────────────────┘
│
│ ─── in the background ───
│ ┌───────────────────────┐
│ │ DREAMING │
│ │ async reasoning that │
│ │ refines each peer's │
│ │ model between turns │
│ └───────────────────────┘
What "dreaming" actually is
Between explicit calls, Honcho runs background reasoning on each peer — pattern identification, hypothesis testing, conflict resolution against new evidence, weighting of prior conclusions. It's an asynchronous learning loop that improves the state you'll fetch on the next context() call, without slowing down inference.
This is the piece that distinguishes it from "vector store with a summary" implementations. Memory that reasons vs. memory that retrieves.
Five reasoning tiers on demand
The .chat() call is priced by depth. Cheap tiers for lookups you'd do at every turn; expensive tiers for the once-per-session syntheses you actually want a real answer for.
| Tier | Cost / query | Latency | Example query |
|---|---|---|---|
| Minimal | $0.001 | instant | "What's the user's name?" · single semantic lookup |
| Low | $0.01 | instant | "When's the user's birthday?" · conclusions with surrounding context (default tier) |
| Medium | $0.05 | fast | "Describe the user's communication style" · multiple searches, directed synthesis |
| High | $0.10 | async | "How has the user's sentiment evolved?" · multi-pass analysis over time |
| Max | $0.50 | async | "Build a churn-risk assessment" · exhaustive full-history with quantitative methods |
The economic point: cheap tiers make sense to call every turn (they're basically free), expensive tiers make sense once per session or per critical decision. Compare this to a naive "give me everything and let the LLM sort it out" pattern where you pay top-line inference cost every time regardless of query difficulty.
Ingestion is priced separately at $2.00/M tokens. context() is unlimited (no per-call fee) — this is the "call at every turn" primitive.
Different axis from Orectic and Penumbra
Orectic and Penumbra argue about how to build the same thing — a typed model of your business. Honcho isn't a third answer to that argument. It's building a typed model of a different subject: the peers your agent talks to. Same shape, different topic.
THREE PRODUCTS, TWO AXES
what the memory is ABOUT ─────────────────────────────────────────
business objects peers / entities
───────────────── ──────────────────
Customer, Renewal, User "Alex", Agent
Decision, Deliverable "Coach", NPC "Merchant"
how the schema GETS BUILT ─────────────────────────────────────
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ DECLARED │ │ EXTRACTED │ │ LEARNED │
│ (top-down) │ │ (bottom-up) │ │ (continual) │
│ │ │ │ │ │
│ humans write │ │ engine mines │ │ reasoning │
│ the ontology │ │ from your files│ │ updates it live│
│ │ │ │ │ │
│ PENUMBRA │ │ ORECTIC │ │ HONCHO │
│ ──────── │ │ ─────── │ │ ────── │
│ business │ │ business │ │ peers / │
│ ontology │ │ ontology │ │ entities │
└────────────────┘ └────────────────┘ └────────────────┘
├─── same subject, opposite methods ───┤ ├─ different subject ─┤
Side-by-side
| Dimension | Orectic | Penumbra | Honcho |
|---|---|---|---|
| Subject of memory | business objects | business objects | peers |
| Schema source | extracted from files | declared by experts | learned continually |
| Primary artifact | Oracle agent | typed substrate | context() API |
| Product surface | finished agent | platform | developer API |
| Reasoning trigger | on query | on query | on ingest AND query AND background |
| Pricing | $1,500/mo starting | not public | $2/M ingest + $0.001–$0.50/query |
| Evidence | one client case | research preview | LongMem, LoCoMo, BEAM · SOC 2 · open evals |
| Drop-in for your stack | ✗ none | ✗ none | ✓ OpenClaw · Hermes · Claude Code |
| Fails when | truth isn't written down | nobody has time to model | you're modeling business objects not peers |
The important note: Honcho does not compete with Orectic or Penumbra. It complements them. Orectic can tell you the Acme renewal decision (DISC-2156, Marta L., 15% off). Honcho can tell you that when Alex from CS looks up any Acme decision, they want a specific tone of follow-up email and don't want to be reminded of the CFO's pushback because they've already read it. Different memories, both useful. A mature stack has both.
The evidence gap
Honcho is the most-evidenced of the three by a wide margin. Public benchmarks, open evals repo, SOC 2 Type I, open source, a published model card. This is the section where the comparison gets uncomfortable for Orectic and Penumbra.
Open benchmarks
| Benchmark | Honcho | What it measures |
|---|---|---|
| LongMem S | 90.4% | long-context memory over interleaved sessions |
| LoCoMo | 89.9% | long-conversation memory across topic changes |
| BEAM 100K | 0.630 | memory-augmented reasoning at 100K token history |
| BEAM 500K | 0.646 | same, at 500K tokens |
| BEAM 1M | 0.618 | same, at 1M tokens |
| BEAM 10M | 0.409 | same, at 10M tokens — the frontier they admit degrades |
Numbers verifiable at evals.honcho.dev and reproducible from plastic-labs/honcho-benchmarks on GitHub.
Trust & transparency signals
SOC 2 Type I
Certified via Delve. Meaningful for anyone deploying against real user data.
Open source core
plastic-labs/honcho on GitHub. AGPL-adjacent posture, real repo, active commits.
Open eval methodology
Benchmark harness is public and forkable. Not "trust us" — reproducible.
Model card
Neuromancer (their reasoning model) has a published card on HuggingFace plastic-labs.
Native plugins for what you already run
This is the largest practical differentiator versus Orectic and Penumbra. Honcho ships first-class plugins for OpenClaw, Hermes Agent, and Claude Code. All three are things Organized AI already runs. Neither Orectic nor Penumbra has a drop-in path into this stack.
OpenClaw plugin
Memory for WhatsApp, Telegram, Discord, Slack agents running on OpenClaw. Restarts the gateway once and it's wired.
Hermes Agent
The NousResearch Hermes Agent has built-in Honcho support. hermes memory setup honcho. Directly relevant to claws-mac-mini.
Claude Code plugin
Persistent memory across CC sessions. Installed via /plugin install honcho@honcho. Solves the "every session is day one" problem.
Agent skill (npx)
For any integration outside the above. Install as a Claude skill via npx skills add plastic-labs/honcho.
Install commands (verbatim from honcho.dev)
# OpenClaw openclaw plugins install @honcho-ai/openclaw-honcho openclaw gateway restart # Hermes Agent (NousResearch) curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash hermes memory setup honcho # Claude Code /plugin marketplace add plastic-labs/claude-honcho /plugin install honcho@honcho # Universal skill (npx) npx skills add plastic-labs/honcho
None of these require touching your existing Orectic-vs-Penumbra evaluation. They can run alongside as a parallel bet.
When to reach for Honcho
A tight framework for deciding whether to add Honcho to a stack, keeping Orectic/Penumbra as separate decisions on the business-memory side.
Stack & conventions
Same single-file HTML pattern as the other four sibling sites. Dark terminal theme, monospace topbar, sticky sidebar. ASCII diagrams use highlight spans — this page adds purple (.hp) as the Honcho-specific accent to visually distinguish it from Orectic (amber) and Penumbra (teal) in shared diagrams.
Deploy & run
CLOUDFLARE_ACCOUNT_ID=691fe25d377abac03627d6a88d3eeac9 \ wrangler pages project create orectic-penumbra-honcho \ --production-branch main 2>/dev/null || true cd docs/honcho CLOUDFLARE_ACCOUNT_ID=691fe25d377abac03627d6a88d3eeac9 \ wrangler pages deploy . \ --project-name orectic-penumbra-honcho \ --branch main \ --commit-dirty=true