Honcho README Competitive Audit

Date researched: 2026-04-27

Scope:

Audit the root README.md for freshness, ordering, and approachability.
Compare Honcho against the public READMEs for the memory and agent-memory projects listed by Twitter handle.
Recommend concrete changes that make Honcho’s README more informative, easier to start with, and more competitive.

Executive Summary

Honcho’s README has the right core positioning: open source memory infrastructure with a managed service for building stateful agents. The main gap is not the product story itself. The gap is that the root README reads more like a server repository and self-hosting manual than a high-conversion product README for both:

Developers adding memory to their own applications.
Individuals adding persistent memory to agentic tools such as Claude Code, OpenCode, Hermes Agent, OpenClaw, Cursor, and other MCP clients.

The strongest competitor READMEs now split the first screen into audience-based paths. Supermemory does this most directly with “I use AI tools” and “I’m building AI products.” Letta does a CLI/API split. Mem0 does Library/Self-Hosted/Cloud. Hindsight leads with a two-line wrapper path plus deeper API control. Cognee, Supermemory, Hindsight, SimpleMem, MemOS, and memU all surface MCP, Claude Code, OpenClaw, or agent-skill onboarding much more prominently than Honcho’s root README.

Honcho already has the material in docs: MCP setup, Claude Code plugin, OpenCode plugin, OpenClaw guide, Hermes guide, CLI, and /honcho-integration agent skills. The README should expose those paths above local development and configuration.

Current Honcho README Assessment

Strengths

The opening paragraph is clear about Honcho being open source memory infrastructure plus a managed service.
The “peer” model is a meaningful differentiator: users, agents, groups, ideas, and other entities are first-class.
The README quickly shows core SDK operations: workspace, peers, session, messages, chat, context, search, representation.
It links to evals, blog, docs, PyPI, npm, Discord, app signup, and AGPL license.
It documents self-hosting requirements in enough depth for contributors and operators.

Freshness and correctness issues

These are concrete issues to fix in the root README:

Location	Issue	Recommended fix
`README.md:48`	Quickstart initializes `Honcho(workspace_id="my-app-testing")` without mentioning `HONCHO_API_KEY` or `api_key`. Current v3 quickstart says an API key is required for the managed API.	Add `export HONCHO_API_KEY=...` before the example or pass `api_key=os.environ["HONCHO_API_KEY"]`.
`README.md:31`	Says TypeScript examples are in docs, but the root README only gives Python. Competitors commonly show Python and TypeScript side by side.	Include a compact TypeScript tab/block or link a visible “TypeScript quickstart” immediately below the Python example.
`README.md:82`	Uses `model="gpt-4"` in the OpenAI example. This reads dated and can go stale.	Use `model=os.environ.get("OPENAI_MODEL", "...")` or avoid hardcoding a vendor model in the root README.
`README.md:134`	SDK Reference link points to `https://docs.honcho.dev/v3/documentation/tutorial/SDK`, which 404s.	Change to `https://docs.honcho.dev/v3/documentation/reference/sdk`.
`README.md:137`	API Reference link points to `https://docs.honcho.dev/api-reference/introduction`, which 404s.	Change to `https://docs.honcho.dev/v3/api-reference/introduction`.
`README.md:158`	”This guide was made using a M3 Macbook Pro” is too environment-specific for a top-level README.	Move to troubleshooting docs or remove.
`README.md:291-341`	Pre-commit hook details appear before Docker and architecture. This is contributor detail, not first-read product information.	Move to `CONTRIBUTING.md` or collapse to one sentence and a link.
`README.md:502-567`	Collections/Documents are presented as public primitives, but current v3 docs and API reference emphasize Workspaces, Peers, Sessions, Messages, Conclusions, Representations, Peer Cards, Search, Context, and file upload. Collections/Documents appear mostly internal/reserved.	Reframe collections/documents as internal storage for representations, or remove from the public concept diagram.
`README.md:610`	Chat Endpoint links to an archived blog post for “Dialectic API.”	Link to current docs: `https://docs.honcho.dev/v3/documentation/features/chat`.
`README.md:617`	Still calls it “Dialectic API” immediately after “Chat Endpoint.” This may be legacy terminology for new users.	Prefer “Chat Endpoint” consistently, with “formerly Dialectic” only if needed.
`README.md:289`	Minor grammar: “deriver’s” should be “derivers.”	Fix grammar while editing.

Adjacent doc drift that affects README trust:

docs/v3/documentation/reference/sdk.mdx says “Without configuration, the SDK defaults to the demo server” and lists HONCHO_BASE_URL, but current SDK code defaults to https://api.honcho.dev and reads HONCHO_URL. If the README links users there, this inconsistency should be fixed too.
PyPI currently shows honcho-ai version 2.1.1 released Apr 10, 2026. Local SDK packages are also 2.1.1, while the server badge is 3.0.6. This is not inherently wrong, but the README should clarify “Server 3.0.6” versus “SDK 2.1.1” if versioning confuses users.

Order and approachability

The current order is:

Product pitch.
Python TL;DR.
Project structure.
Usage.
Local development.
Configuration.
Architecture.
Contributing/license.

This is sane for maintainers, but not optimal for a competitive memory framework README. It buries:

MCP and agent-tool usage.
Claude Code/OpenCode/OpenClaw/Hermes integrations.
Agentic onboarding skills.
Benchmarks/evals details.
“When should I use this?” guidance.
Simple managed-vs-self-hosted choice points.

The result is that Honcho looks narrower than it is. The product supports both developer infrastructure and user-facing agent memory workflows, but the README mostly communicates “Python SDK plus server setup.”

Competitor README Section Inventory

@mem0ai → `mem0ai/mem0`

Source: https://github.com/mem0ai/mem0

Sections covered:

Badge/link bar.
New Memory Algorithm announcement with benchmark table.
“What changed” algorithm notes.
Research highlights.
Introduction.
Key features and use cases.
Quickstart guide with Library vs Self-Hosted Server vs Cloud Platform choice table.
Library install via pip/npm.
Self-hosted server bootstrap.
Cloud platform signup.
CLI install and example commands.
Basic usage chatbot example.
Integrations and demos.
Documentation and support.
Citation.
License.

Competitive observations:

Strong trust signal at the very top via benchmarks and research.
Clear “choose your setup” table reduces onboarding uncertainty.
CLI is treated as a first-class path, not an afterthought.
Basic usage is a complete memory loop: retrieve memories, prompt an LLM, add new memories.

@zep_ai → Zep ecosystem: `getzep/zep` and `getzep/graphiti`

Sources:

Why both: the user’s star count maps more closely to getzep/graphiti, while getzep/zep is the Zep examples/integrations repository. Zep’s README itself points to Graphiti as the open-source temporal knowledge graph framework powering Zep.

getzep/zep sections covered:

Product title: end-to-end context engineering platform.
Examples, integrations, and more.
What is Zep?
How Zep works: add context, graph RAG, retrieve and assemble.
Getting started with Zep Cloud.
SDKs for Python, TypeScript/JavaScript, and Go.
Help links.
About this repository.
Repository structure.
Development setup.
Contributing.
Graphiti explanation.
Community Edition legacy note.

getzep/graphiti sections covered:

Product title: temporal context graphs for AI agents.
Hiring/community note.
MCP server tip.
What Graphiti is.
What a context graph is.
Component table: entities, facts/relationships, episodes, custom types.
Graphiti and Zep relationship.
Zep vs Graphiti comparison table.
Why Graphiti.
Graphiti vs GraphRAG comparison table.
Installation and backend requirements.
Provider and concurrency notes.
Quick start.
Docker Compose.
MCP server.
REST service.
Optional environment variables.
Provider-specific setup for Azure OpenAI, Gemini, Ollama.
Documentation.
Telemetry disclosure.
Contributing/support.

Competitive observations:

Zep/Graphiti are very explicit about “Zep vs Graphiti” and “Graphiti vs GraphRAG.” Honcho should add a short “Honcho vs RAG/vector DB/memory-only systems” section.
Graphiti’s context graph definition is concrete and easy to reason about. Honcho should similarly define “peer representation” with a small example.
Telemetry disclosure improves trust. Honcho could briefly explain managed vs self-hosted data boundaries.

@Letta_AI → `letta-ai/letta`

Source: https://github.com/letta-ai/letta

Sections covered:

Title and formerly-MemGPT identifier.
One-line pitch: build AI with advanced memory that can learn and self-improve.
Two product paths: Letta Code and Letta API.
CLI getting started.
API getting started.
SDK installation for TypeScript and Python.
Hello World examples in TypeScript and Python.
Contributing/community.
Legal notices.

Competitive observations:

Very short and path-driven.
The first thing users choose is CLI or API, which mirrors Honcho’s emerging split: “Use Honcho in agent tools” vs “Build Honcho into your app.”
The Hello World creates an agent and sends a message. Honcho can be more infrastructure-accurate by showing “store messages → ask what was learned → inject context.”

@supermemory → `supermemoryai/supermemory`

Source: https://github.com/supermemoryai/supermemory

Sections covered:

Logo, docs, quickstart, dashboard, Discord.
State-of-the-art memory/context engine claim.
Benchmark claims across LongMemEval, LoCoMo, ConvoMem.
Feature table: memory, user profiles, hybrid search, connectors, multimodal extractors.
“Use Supermemory” with two paths: “I use AI tools” and “I’m building AI products.”
Consumer app setup.
Plugins for Claude Code, OpenCode, OpenClaw, Hermes.
MCP quick install one-liner.
MCP tools table.
How it works for AI-tool users.
Supported clients.
Manual MCP configuration.
API installation.
TypeScript and Python quickstarts.
Framework integrations.
Search modes.
User profiles.
Connectors.
API at a glance.
Benchmarks.
MemoryBench benchmark command and agent skill.
How memory works under the hood.
Memory vs RAG explanation.
Automatic forgetting.
Links.

Competitive observations:

This is the clearest model for Honcho’s dual audience.
It turns B2C-style usage into a first-class README path without diluting the developer API story.
The MCP one-liner is a major accessibility advantage.
The “API at a glance” table helps users quickly understand surface area.

@cognee_ → `topoteretes/cognee`

Source: https://github.com/topoteretes/cognee

Sections covered:

Link bar: demo, docs, learn more, Discord, Reddit, community plugins.
Social badges and translations.
About Cognee.
Why use Cognee.
Product features image.
Colab walkthrough.
Quickstart with prerequisites, install, LLM config, pipeline.
Four operations: remember, recall, forget, improve.
CLI commands and local UI.
AI agent integrations: Claude Code, Hermes Agent.
Cloud connection.
Examples/use cases.
Deployment table: Cloud, Modal, Railway, Fly.io, Render, Daytona.
Latest news.
Community/support.
Contributing/code of conduct.
Research/citation.

Competitive observations:

Strong operation verbs: remember/recall/forget/improve. Honcho’s equivalents could be framed as store, reason, query, inject.
Cognee surfaces Claude Code and Hermes directly in README.
Deployment choices are in a table, making self-hosting feel less intimidating.

@memU_ai → `NevaMind-AI/memU`

Source: https://github.com/NevaMind-AI/memU

Sections covered:

Banner, badges, translations.
24/7 proactive memory pitch.
OpenClaw alternative / memU Bot.
Memory as file system explanation.
Star request.
Core feature table.
How proactive memory works.
Proactive memory lifecycle diagram.
Proactive use cases.
Hierarchical memory architecture.
Quick start: cloud and self-hosted.
Cloud API table.
Installation and basic examples.
Custom LLM/embedding providers.
OpenRouter integration.
Core APIs: memorize and retrieve.
Proactive scenarios.
Performance.
Ecosystem.
Partners.
How to contribute.
License/community.

Competitive observations:

The filesystem analogy is memorable and concrete.
Proactive use cases are vivid, though the README is long.
Honcho should not copy the length, but should add 2-3 concrete use cases near the top.

@Vectorizeio Hindsight → `vectorize-io/hindsight`

Source: https://github.com/vectorize-io/hindsight

Sections covered:

Banner and link bar: docs, paper, cookbook, cloud.
What is Hindsight?
Memory performance and accuracy.
Adding Hindsight to your agents.
LLM wrapper path with “2 lines of code.”
SDK/API path for more control.
Coding-agent docs skill.
Quick start: Docker, Docker with external PostgreSQL, client SDKs, Python embedded.
Use cases.
Per-user memories and chat history.
Architecture and operations.
Memory model: world, experiences, mental models.
Three operations: retain, recall, reflect.
Retain examples.
Recall examples and retrieval strategies.
Reflect examples.
Resources.
Star history.
Contributing/license.

Competitive observations:

The best onboarding idea here is the “wrapper first, API second” path. Honcho may not have a direct LLM wrapper, but it can create an equivalent “minimal integration” path for context injection.
The coding-agent docs skill is surfaced near the top. Honcho has agent skills and should do the same.
“Retain/Recall/Reflect” is a clean mental model. Honcho should give similarly simple operation names before deeper peer/session details.

@MemOS_dev → `MemTensor/MemOS`

Source: https://github.com/MemTensor/MemOS

Sections covered:

Product title and performance claims.
Enhanced OpenClaw with Cloud and Local plugin paths.
What is MemOS?
Key features.
News.
Quickstart: Cloud API and self-hosted.
Basic self-hosted usage with add/search.
Resources.
Community/support.
Citation.
Contributing/license.

Competitive observations:

The OpenClaw plugin is first-screen content, not buried in docs.
Cloud/local split is clear.
The README is benchmark-heavy and news-heavy; Honcho can be more restrained while still surfacing evals.

@HuaxiuYaoML SimpleMem → `aiming-lab/SimpleMem`

Source: https://github.com/aiming-lab/SimpleMem

Sections covered:

Title and cross-platform support.
Platform badges: Claude Desktop, Cursor, LM Studio, Cherry Studio, PyPI, MCP.
Translations.
Project/demo badges.
News.
Table of contents.
Quick start.
Basic workflow: store, index, retrieve.
Basic usage with auto backend selection.
Text and multimodal examples.
Advanced parallel processing.
Overview.
Three-stage architecture.
Performance comparison.
Benchmark results.
Text memory details.
Omni-SimpleMem multimodal memory.
Installation.
Docker.
Router utilities.
Troubleshooting.
Cross-session memory.
MCP server.
Roadmap.
Evaluation.
Citation/license/acknowledgments.

Competitive observations:

SimpleMem is extremely research-forward, but still starts with a runnable example.
“Basic workflow” before architecture is a good pattern.
The troubleshooting section is useful for first-time users.

@agentscope_ai → `agentscope-ai/agentscope`

Source: https://github.com/agentscope-ai/agentscope

Note: AgentScope is a broader agent framework, not a dedicated memory framework. It is still relevant because memory is part of its value proposition.

Sections covered:

Logo and top links.
What is AgentScope?
Why use AgentScope?
Ecosystem image.
News.
Community.
Table of contents.
Quickstart installation.
Example: Hello AgentScope.
Voice agent.
Realtime voice agent.
Human-in-the-loop.
Flexible MCP usage.
Agentic RL.
Multi-agent workflows.
Documentation.
More examples and samples by category.
Contributing/license.
Publications.
Contributors.

Competitive observations:

Strong examples catalog.
It does not lead with memory, but it shows how a framework README can use examples to communicate breadth.
Honcho should add a compact integrations/examples catalog instead of only linking generic docs.

Cross-Competitor Patterns Worth Adopting

1. Audience split above the fold

Best examples:

Supermemory: “I use AI tools” vs “I’m building AI products.”
Letta: “Letta Code” vs “Letta API.”
Mem0: Library vs Self-Hosted Server vs Cloud Platform.

Recommended Honcho version:

I want to…	Start here	Command/link
Give my coding agent persistent memory	Claude Code / OpenCode / MCP	`/plugin marketplace add plastic-labs/claude-honcho` or `bunx @honcho-ai/opencode-honcho install`
Add memory to my product	Python / TypeScript SDK	`uv add honcho-ai` or `npm install @honcho-ai/sdk`
Self-host Honcho	Docker / local development	Link to self-hosting docs

2. One-liners and agentic onboarding

Competitors increasingly treat agents as the onboarding channel. Hindsight and Supermemory both surface agent skills; Supermemory, Cognee, MemOS, memU, and SimpleMem all surface MCP/plugin flows.

Honcho already has good one-liners in docs. They should be in the root README:

# Claude Code plugin
/plugin marketplace add plastic-labs/claude-honcho

# OpenCode plugin
bunx @honcho-ai/opencode-honcho install

# OpenClaw plugin
openclaw plugins install @honcho-ai/openclaw-honcho
openclaw honcho setup
openclaw gateway --force

# Agent skill for adding Honcho to an existing codebase
npx skills add plastic-labs/honcho

The README should also mention the /honcho-integration skill: it explores the user’s codebase, asks integration questions, implements the SDK wiring, and verifies the result.

3. Simple operation model before internal concepts

Competitors use memorable verbs:

Mem0: add/search.
Cognee: remember/recall/forget/improve.
Hindsight: retain/recall/reflect.
Supermemory: add/profile/search/context.

Recommended Honcho framing:

Store messages and events.
Let Honcho reason in the background.
Query peer representations, conclusions, search results, or session context.
Inject that context into any model or agent framework.

Then introduce Workspaces, Peers, Sessions, and Messages.

4. Benchmark and trust signal near the top

Honcho has an evals link in the opening block, but competitors use compact benchmark tables or explicit metrics. Honcho should add a small “Why Honcho” table:

Capability	What it means
Reasoning-first memory	Extracts conclusions from conversations and events, not just matching chunks.
Peer-centric model	Tracks users, agents, groups, projects, and ideas as entities that change over time.
Multi-peer perspective	Models what one peer knows about another when configured.
Managed or self-hosted	Use `api.honcho.dev` or run the FastAPI service yourself.
Agent-tool integrations	MCP, Claude Code, OpenCode, OpenClaw, Hermes, Cursor-compatible clients.

If benchmark numbers are included, link directly to methodology and keep claims reproducible.

5. API surface at a glance

Supermemory’s “API at a glance” table is useful. Honcho should include a compact equivalent:

Need	Honcho API/SDK
Save interaction history	`session.add_messages(...)`
Ask what Honcho knows	`peer.chat(...)`
Get prompt-ready context	`session.context(...).to_openai(...)` / `.to_anthropic(...)`
Search raw history	`peer.search(...)`, `session.search(...)`, `honcho.search(...)`
Retrieve low-latency memory	`peer.context(...)`, `peer.representation(...)`, `session.representation(...)`
Import documents	`session.upload_file(...)`
Inspect background processing	`honcho.queue_status(...)`

Priority Recommendations

P0: Fix stale or broken content

Fix the two broken docs links.
Add API-key setup to the root quickstart.
Replace the archived Chat/Dialectic blog link with the current Chat Endpoint docs.
Update or remove public Collections/Documents sections unless they are intentionally user-facing.
Align HONCHO_URL vs HONCHO_BASE_URL in adjacent SDK docs before linking them heavily.

P1: Reposition for both audiences

Add “I use AI tools” and “I am building AI products” paths above the SDK quickstart.
Surface Claude Code, OpenCode, OpenClaw, Hermes, and MCP in the root README.
Add agentic onboarding via npx skills add plastic-labs/honcho and /honcho-integration.

P2: Improve quickstarts

Add TypeScript side-by-side with Python.
Add a runnable “store → reason → query → inject context” example.
Include a small expected output or explanation so unfamiliar readers understand what Honcho learned.
Add queue/status note if reasoning is asynchronous and results may take a moment.

P3: Make the README easier to scan

Replace “Project Structure” with “Contents.”
Move pre-commit hooks to CONTRIBUTING.md.
Compress local development and Fly deployment to links.
Add a feature/API table and integration table.

P4: Sharpen competitive differentiation

Add “Honcho vs RAG” and “Honcho vs basic memory search” explanations.
Emphasize peer-centric memory, multi-peer perspective, theory-of-mind style reasoning, and changing-state support.
Add a compact evals/benchmark section with reproducible links.
Add a Mem0 migration link since the docs already include one.

What Not To Copy

Do not copy competitors’ very long news sections near the top. They make READMEs feel stale quickly.
Do not over-index on benchmark claims without enough methodology. Honcho’s “Pareto Frontier” claim is stronger if the README links a small table to reproducible evals.
Do not lead with infrastructure setup. Developers want to see value before Docker, config, pre-commit, and Fly.
Do not make agent integrations look secondary. The market is clearly moving toward MCP/plugin/agent-skill onboarding.

Source Links

Honcho README: https://github.com/plastic-labs/honcho
Honcho v3 quickstart: https://docs.honcho.dev/v3/documentation/introduction/quickstart
Honcho SDK reference: https://docs.honcho.dev/v3/documentation/reference/sdk
Honcho API reference: https://docs.honcho.dev/v3/api-reference/introduction
Honcho Agentic Development: https://docs.honcho.dev/v3/documentation/introduction/vibecoding
Honcho MCP: https://docs.honcho.dev/v3/guides/integrations/mcp
Honcho Claude Code: https://docs.honcho.dev/v3/guides/integrations/claude-code
Mem0: https://github.com/mem0ai/mem0
Zep: https://github.com/getzep/zep
Graphiti: https://github.com/getzep/graphiti
Letta: https://github.com/letta-ai/letta
Supermemory: https://github.com/supermemoryai/supermemory
Cognee: https://github.com/topoteretes/cognee
memU: https://github.com/NevaMind-AI/memU
Hindsight: https://github.com/vectorize-io/hindsight
MemOS: https://github.com/MemTensor/MemOS
SimpleMem: https://github.com/aiming-lab/SimpleMem
AgentScope: https://github.com/agentscope-ai/agentscope

Plastic Labs Internal Wiki

Explorer

Recently Updated

Company

Operating Model — Decisions Log

Operating Model

Security & Compliance

ideal-reasoned-representations

readme-seo-changes

Honcho README Competitive Audit

Executive Summary

Current Honcho README Assessment

Strengths

Freshness and correctness issues

Order and approachability

Competitor README Section Inventory

@mem0ai → mem0ai/mem0

@zep_ai → Zep ecosystem: getzep/zep and getzep/graphiti

@Letta_AI → letta-ai/letta

@supermemory → supermemoryai/supermemory

@cognee_ → topoteretes/cognee

@memU_ai → NevaMind-AI/memU

@Vectorizeio Hindsight → vectorize-io/hindsight

@MemOS_dev → MemTensor/MemOS

@HuaxiuYaoML SimpleMem → aiming-lab/SimpleMem

@agentscope_ai → agentscope-ai/agentscope

Cross-Competitor Patterns Worth Adopting

1. Audience split above the fold

2. One-liners and agentic onboarding

3. Simple operation model before internal concepts

4. Benchmark and trust signal near the top

5. API surface at a glance

Recommended New README Order

Suggested README Copy Snippets

Priority Recommendations

P0: Fix stale or broken content

P1: Reposition for both audiences

P2: Improve quickstarts

P3: Make the README easier to scan

P4: Sharpen competitive differentiation

What Not To Copy

Source Links

Graph View

Table of Contents

Backlinks

@mem0ai → `mem0ai/mem0`

@zep_ai → Zep ecosystem: `getzep/zep` and `getzep/graphiti`

@Letta_AI → `letta-ai/letta`

@supermemory → `supermemoryai/supermemory`

@cognee_ → `topoteretes/cognee`

@memU_ai → `NevaMind-AI/memU`

@Vectorizeio Hindsight → `vectorize-io/hindsight`

@MemOS_dev → `MemTensor/MemOS`

@HuaxiuYaoML SimpleMem → `aiming-lab/SimpleMem`

@agentscope_ai → `agentscope-ai/agentscope`