AI Frameworks · plastic-labs

honcho

Honcho is a memory infrastructure platform for AI agents that persists conversations, events, and context over time. It extracts reasoning from interactions to build agent-aware representations and can be deployed as a managed service or self-hosted FastAPI server.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/plastic-labs/honcho

5.8k

GitHub stars

698

Forks

Python

Primary language

AGPL-3.0

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	plastic-labs/honcho
Owner	plastic-labs
Primary language	Python
License	AGPL-3.0 — OSI-approved
Stars	5.8k
Forks	698
Open issues	152
Latest release	Unknown
Last updated	2026-07-08
Source	https://github.com/plastic-labs/honcho

What honcho is

Python/TypeScript library providing peer-centric state management for agents via reasoning-first memory. Supports hybrid search (BM25 + vector), multi-peer perspective modeling, and background asynchronous reasoning with FastAPI backend.

Quickstart

Get the honcho source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/plastic-labs/honcho.git2cd honcho3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Persistent Agent Memory for Coding Assistants

Integrate with Claude Code, OpenCode, or MCP-compatible tools to give agents long-term context about user preferences, past interactions, and project state across sessions.

Multi-Agent Conversation State Management

Track interactions between multiple agents/users/groups over time, maintaining peer representations and enabling agents to understand changing relationships and context.

Reasoning-Driven Context Injection

Extract conclusions and peer understanding from conversation history, then inject structured, prompt-ready context into LLM calls without manual parsing or chunking.

Implementation considerations

AGPL-3.0 licensing requires careful review for commercial products; managed service use (api.honcho.dev) may simplify compliance but does not obviate source obligations for derivatives.
Background reasoning is async; application logic must handle eventual consistency and may need polling or webhooks for state updates.
Managed service includes $100 free credits per workspace, but production deployment costs depend on message volume, reasoning complexity, and LLM inference on Honcho's backend.
Peer-centric model requires careful schema design; misaligned peer/session/message relationships can lead to incorrect context extraction and reasoning.
SDK available in Python and TypeScript; other languages require REST API integration.

When to avoid it — and what to weigh

Strict Real-Time Latency Requirements — Background reasoning is asynchronous; newly-added messages may take time to reflect in query responses. Low-latency reads require explicit use of the representation endpoint.
Proprietary/Closed-Source Requirement — Licensed under AGPL-3.0, which requires source disclosure for networked services. Commercial closed-source deployments require review or license negotiation with Plastic Labs.
No LLM Dependencies Acceptable — Reasoning layer relies on LLM calls for extraction and inference; not feasible for offline-only or no-LLM environments.
Minimal Observability/Debugging Needs — Requires understanding of async queue processing, peer representation lifecycle, and API response shapes; integration debugging can be complex without domain familiarity.

License & commercial use

AGPL-3.0 (GNU Affero General Public License v3.0). Copyleft license requiring source disclosure for any networked service modifications or derivative works. Not a permissive OSI license for proprietary closed-source use.

Managed service at api.honcho.dev appears to be the intended commercial offering (with free credits and paid tiers). Self-hosted AGPL-3.0 deployment for commercial purposes requires careful compliance review or explicit license agreement with Plastic Labs. Using the managed service likely avoids derivative source disclosure, but this requires independent verification.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Strong
License clarity	Needs review
Deployment complexity	Moderate
DEV.co fit	Strong
Assessment confidence	High

Security considerations

Managed service stores API key at api.honcho.dev; use environment variables and rotate keys regularly. Self-hosted deployments must secure FastAPI server, vector database, and background queue. AGPL-3.0 requires source review if deploying modifications; no explicit security audit mentioned. Peer representations are queryable via API; ensure access controls on peer/workspace data.

Alternatives to consider

Langchain's memory layers + vector stores (Pinecone, Weaviate, Milvus)

More modular; combines off-the-shelf components but requires manual reasoning logic, context assembly, and peer modeling.

Mem0 (open-source memory OS)

Similar goal of persistent agent memory; likely different licensing and architecture—requires comparative evaluation.

LlamaIndex (structured indexing + retrieval) + custom state management

Flexible indexing and retrieval; does not abstract peer reasoning or multi-agent state, so more DIY engineering required.

Software development agency

Build on honcho with DEV.co software developers

Get started with Honcho's managed service (free $100 credits) or self-host the FastAPI server. Python and TypeScript SDKs ready to integrate.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

EverOS memanto ml-engineering

Related on DEV.co

Explore the category and the services that help you build with it.

AI Frameworks AI Application Development API Development Cloud Deployment Talk to DEV.co

honcho FAQ

Can I use Honcho in a closed-source commercial product?

Using the managed service (api.honcho.dev) likely avoids AGPL source disclosure obligations, but this requires legal review. Self-hosting AGPL-3.0 code for a networked service typically requires source release or explicit license negotiation with Plastic Labs.

How long does background reasoning take?

Not specified in the provided data. Documentation notes messaging may take 'a moment' to reflect in chat responses; use the representation endpoint for immediate read-after-write, or check queue_status() for processing details.

Does Honcho handle embeddings?

Hybrid search (BM25 + vector) is mentioned, but whether Honcho manages embeddings or requires external services is not clearly stated in the excerpt.

What's the cost of the managed service?

New workspaces receive $100 free credits. Paid pricing is not detailed in the excerpt; see app.honcho.dev for current rates.

Custom software development services

From first prototype to production, DEV.co delivers software development services around tools like honcho. Our software development agency staffs experienced software developers and web developers for custom software development, web development, integrations, and ongoing support across ai frameworks and beyond.

Build agents that remember and understand context.

Get started with Honcho's managed service (free $100 credits) or self-host the FastAPI server. Python and TypeScript SDKs ready to integrate.

Talk to DEV.co Schedule a Consultation