Skip to content
AI Tool

Honcho Review

Honcho is an open-source memory and user-modeling backend for AI agents that reasons over conversations to maintain evolving user context across sessions, tools, and machines.

shipped Oct 26, 2026agentsfreemium
Domain rating58AI-readablestrong
agentsopen-sourcedeveloper-tools

Why it matters

1Founded in 2023; developed by Plastic Labs, with headquarters in Brooklyn, NYC.
2Offers a developer API and MCP integration; API documentation is at honcho.dev/docs/.
3Pricing includes memory at $2.00 per million tokens ingested and reasoning tiers from $0.001 to $0.50 per query.
4Data retention is 90 days; Honcho is SOC 2 Type I certified and is not HIPAA-aligned or ISO-certified.

About Honcho

Business Model
Open Source
Usage Pricing
$0.001/q per query
Headquarters
Brooklyn, NYC
Founded
2023
Team Size
18
Funding
Seed
Platforms
Web, API
Target Audience
Developers and businesses creating stateful AI agents

Pricing Plans

Honcho Memory
$2.00 / M tokens ingested
  • • Store + Neuromancer reasoning
Minimal Reasoning
$0.001 / query
  • • Basic conclusions — instant
Low Reasoning
$0.01 / query
  • • Efficient synthesis — instant
Medium Reasoning
$0.05 / query
  • • Steerable reasoning — fast
High Reasoning
$0.10 / query
  • • Deep synthesis — async
Max Reasoning
$0.50 / query
  • • Research-grade — async

Cost Examples

  • • Basic conclusions: $0.001/query
  • • Efficient synthesis: $0.01/query
  • • Steerable reasoning: $0.05/query

Leadership

Vineeth VorugantiCo-founderLinkedIn
Courtland LeerCo-founderLinkedIn
API DocsGitHubOpen Source

Specs

API Available

Yes, public API

overview

What is Honcho?

Honcho is an open-source AI memory tool that enables developers and businesses creating stateful AI agents to build persistent, evolving models of users from conversations. It supports memory across sessions, tools, and machines, using conversation reasoning to retain preferences and context. Honcho is provided by Plastic Labs and is designed as a memory and user-modeling backend rather than a full agent runtime.

features

Key Features of Honcho

Honcho provides conversation-derived memory and user modeling for stateful AI agents. Its documented technical scope includes text input, Plastic Labs Neuromancer models, an API, and MCP integration.

  • Reasons over conversations to create evolving models of individual users.
  • Retains preferences and context across sessions, tools, and machines.
  • Provides continual learning for stateful agents.
  • Manages memory with token efficiency to reduce context-token use.
  • Offers granular control over the context supplied to agents.
  • Supports asynchronous reasoning and background inference.
  • Provides a developer API documented at https://honcho.dev/docs/.
  • Lists Plastic Labs Neuromancer and Plastic Labs Neuromancer XR as models; multimodality is text.
  • Supports MCP integration and open-standard function calling.

use cases

Who Should Use Honcho?

Honcho is intended for developers and businesses building AI agents that need user context to persist beyond a single conversation. The listed application areas include customer support, education, gaming, productivity, and AI companionship.

  • AI agent developers building stateful experiences with persistent user preferences.
  • Customer-support teams creating agents that use context from earlier interactions.
  • Education applications that need to carry learner context between sessions.
  • Gaming and AI companionship products that use evolving user models.
  • Productivity tools that need agents to retain context across sessions and tools.

how to use

How to Use Honcho

Developers can begin with the Honcho API documentation at https://honcho.dev/docs/ and connect an agent through the API or MCP. Configure the memory and reasoning usage to suit the application; the published pricing distinguishes memory ingestion from reasoning queries.

  • 1Review the API documentation at https://honcho.dev/docs/.
  • 2Create or configure a Honcho project and connect it to the agent through the API or MCP.
  • 3Send conversation text to Honcho for user-model and memory processing.
  • 4Retrieve relevant user context for subsequent agent interactions.
  • 5Choose reasoning intensity and monitor memory-ingestion and query usage.

pricing

Honcho Pricing & Plans

Honcho is listed as freemium, with usage prices for memory ingestion and reasoning. Memory is listed at $2.00 per million tokens ingested. Reasoning tiers are priced per query; the available facts do not specify the included free-tier allowance or whether these prices are current, so confirm rates on Honcho’s website before purchase.

  • Honcho Memory: $2.00 per million tokens ingested.
  • Minimal Reasoning: $0.001 per query.
  • Low Reasoning: $0.01 per query.
  • Medium Reasoning: $0.05 per query.
  • High Reasoning: $0.10 per query.
  • Max Reasoning: $0.50 per query.
  • Usage pricing is also listed as $0.001 per query; the exact relationship between this figure and the named reasoning tiers is not specified.

Enjoying this? Get one like it in your inbox each morning.

one email a day · unsubscribe in two clicks · no third-party tracking

Pros

  • +Open-source architecture for an agent memory and user-modeling backend.
  • +Designed to retain conversation-derived preferences and context across sessions, tools, and machines.
  • +Offers API access and MCP integration, with public API documentation.
  • +Provides separately priced memory ingestion and reasoning tiers.
  • +SOC 2 Type I certified, according to the supplied compliance data.

Cons

  • −Data retention is listed as 90 days, which may not suit applications requiring longer retention.
  • −Not HIPAA-aligned and not ISO-certified, according to the supplied compliance data.
  • −The free-tier allowance is not specified in the available pricing information.
  • −The listed pricing information includes both $0.001 per query and reasoning tiers up to $0.50 per query; their relationship is not explained.
  • −The documented multimodality is text, limiting the stated scope to text-based input.

Similar Tools

Honcho vs Competitors

Honcho is positioned as a plug-in memory and user-modeling backend. The supplied comparisons distinguish it from tools focused on fact extraction, agent runtime management, or knowledge-graph construction; implementation details and product capabilities may vary by provider.

1

Provides a multi-layered extraction pipeline that dynamically extracts, scores, and updates discrete user facts and preferences without manual graph curation.

Mem0 is faster to plug into existing agent stacks like LangChain or AutoGen, but Honcho gives you deeper dialectic user modeling and theory-of-mind representation beyond simple key-value fact extraction.

2
Letta↗

Manages agent memory like an operating system with tiered context windows, editable memory blocks, and git-backed context storage.

Letta is a full stateful agent runtime (formerly MemGPT) that dictates the agent's reasoning loop, whereas Honcho acts purely as a plug-and-play memory and user-modeling backend.

3
Graphiti↗

Constructs an evolving, temporally aware knowledge graph directly from conversational turns and external business data.

Graphiti provides clear entity-relation provenance over time, but you have to self-host Neo4j and write custom extraction logic rather than consuming Honcho's out-of-the-box user-profiling APIs.

4

Combines temporal knowledge graphs with hybrid vector and BM25 search to serve low-latency chat history and automated session summaries.

Zep excels at enterprise context enrichment and temporal fact invalidation, but its primary platform is closed-source managed SaaS, unlike Honcho's open-source architecture.

More on Stork

Related AI Tools

Other tools in this category, matched by shared tags

One short daily email of tools worth shipping. No drip funnel.

one email a day · unsubscribe in two clicks · no third-party tracking

For builders

This page is doing a job for someone else’s tool.

AI agents read it. Buyers land on it. It answers in eight languages and over MCP. Your tool can have one like it — live in 24 hours.