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 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

Honcho operates through two integrated layers:

Memory Layer: Captures all user interactions - messages, preferences, and behavioral patterns - in a user-centric data model that scales from individual conversations to complex multi-agent scenarios. This also queues up messages for the insights layer to process.

Insights 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.

Agents access this understanding through the dialectic endpoint - a natural language API where they can ask specific questions about users and receive 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?”

​
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?

Quick Start Guide

Get up and running with Honcho in minutes

Core Concepts

Understand Honcho’s fundamental concepts

​
Community & Support