When building agents developers often run into the same walls:
“My agent forgets everything between chats”
You need memory: session management, message storage, context handling. It’s table stakes, but surprisingly complex to get right.
“My agent treats everyone exactly the same”
You need personalization: user modeling, preference learning, behavioral adaptation. Now you’re building a social cognition engine
“I’m writing infrastructure instead of features”
You need Honcho Honcho's Hiearchy of Agents Honcho delivers production-ready memory infrastructure from day one. Store conversations, manage sessions, get perfectly formatted context for any LLM. But here’s the magic: while your agents are chatting, Honcho is learning. It builds Theory of Mind models automatically, transforming raw conversations into rich psychological understanding. 
# Start simple - just add messages
session.add_messages([alice.message("I learn best with examples")])

# Get powerful - query user psychology
insight = peer.chat("How should I explain this concept?")
# > "This user learns best through concrete examples..."
Your agents evolve from goldfish to counselor, on the same infrastructure. That’s Honcho. Designed for developers and agents alike:
  • Natural Language Queries: Chat with Honcho in natural language via the Dialectic API and let agents backchannel
  • Automatic Context Management: Smart summarization that respects token limits
  • Native multi-agent support: Break out of User/Assistant Paradigms and build complex multi-agent systems
  • Agent-first interfaces: MCP connections and APIs designed for agents to consume and use as tools
  • Provider Agnostic: Works with any LLM or Agent Framework

​
How It Works

​
Storage

Developers use Honcho to store information about their users and application via two integrated layers: Basic Honcho Flowchart Memory Layer: Captures all user interactions - messages, preferences, and behavioral patterns - in a peer-centric data model that scales from individual conversations to complex multi-agent scenarios. This also queues up messages for the reasoning layer to process. Reasoning Layer: Continuously analyzes stored interactions to build psychological profiles using theory of mind inference, extracting patterns about communication style, decision-making preferences, and mental models.

​
Retrieval

Once data is stored and generated within Honcho, the API exposes several different ways to retrieve and use those insights. Dialectic API: This is the flagship endpoint that allows developers to send natural language queries to Honcho to chat with the representation of each user in your system to get dynamic, in-context actionable insights. Example Queries
  • “What’s the best way to explain technical concepts to this user?”
  • “Is this user more task-oriented or relationship-oriented?”
  • “What time of day is this user most engaged?”
  • “How does this user prefer to receive feedback?”
  • “What are this user’s core values based on our conversations?”
Get Context: This endpoint abstracts context window constraints and continuously retrieves the most relevant and recent data from a conversation. Provide a token budget and Honcho will rturn a combination of summaries and messages that pvoide session context. Use this for creating long-running conversations. We crafted our summaries to provide the most coverage of a session possible. Search: This endpoint allows you to search across Honcho for relevant messages either at the workspace, peer, or session level. This endpoint uses a hybrid search strategy that combines text search and cosine similarity. Working Representations: Get a cached, snapshot of a user in the context of a session. Instead of waiting for an LLM to synthesize an in-context response via the Dialectic endpoint, use this to get recent insights you can plug into your context window.

​
Ideal For

Personalized AI assistants that need to understand individual psychology, not just remember conversations. Customer-facing agents that must adapt their approach based on user communication preferences and emotional context. Multi-agent systems where AI needs to understand human collaborators’ working styles and decision-making patterns. NPCs where you want autonomous agents with a rich and deep personality that isn’t the average sycophantic llm

​
Getting Started

Ready to integrate Honcho into your application?

Quickstart Guide

Get up and running with Honcho in minutes

Core Concepts

Understand Honcho’s fundamental concepts

​
Community & Support