← Back
honchoaiagentsmemoryhermes

Persistent Memory for AI Agents with Honcho

8 min 5/26/2026

The Problem: Agents That Forget

Have you ever chatted with an AI assistant that, mid-conversation, completely forgets what was said before? Or worse: the next day, it remembers nothing you built together?

This is one of the biggest roadblocks to real-world AI agent adoption: the lack of persistent memory. Without it, every conversation starts from scratch — acceptable for simple queries, but unworkable for personal assistants, productivity tools, or agents performing tasks over time.

Enter Honcho, an open-source platform that manages persistent memory for AI agents in an elegant and scalable way.

What is Honcho?

Honcho is an open-source platform by Plastic Labs for managing persistent memory in AI agents. The repository is on GitHub and can be self-hosted or used via managed API.

Instead of every agent reinventing the wheel with vector databases, embeddings, and complex queries, Honcho abstracts all that complexity into a clean API with well-defined concepts.

Core Concepts

  • Session — represents the context of a conversation or interaction. Each user or agent has one or more sessions.
  • Metadata — tags, timestamps, and structured data for filtering and searching memories with precision.

The real differentiator is the three memory types Honcho offers.

The Three Memory Types

Like humans, Honcho separates memory into three categories:

1. Episodic Memory

What happened. Specific events, past interactions, exchanged messages.

Example: “Yesterday at 2 PM, the user asked to create a budget spreadsheet.”

Useful for: long conversation context, resuming interrupted tasks, referencing past interactions.

2. Semantic Memory

What the agent knows. Factual knowledge extracted from interactions — user preferences, learned facts, consolidated information.

Example: “The user prefers responses in English and works with web development.”

Useful for: personalization, recommendations, adaptive behavior over time.

3. Procedural Memory

How to do things. Skills, action sequences, procedures the agent learned.

Example: “To generate a report, the agent must: fetch data from API, format as markdown, send to Slack channel.”

Useful for: workflow agents, automations, tools with specific steps.

Why This Separation Matters

  • Episodic memory is volatile and contextual (useful in the current conversation)
  • Semantic memory is durable and generalizable (useful across sessions)
  • Procedural memory is operational (useful for skills)

Practical Code: Integrating Honcho with Hermes Agent

1. Set Up Honcho Client

from honcho import Honcho

client = Honcho(
    app_name="my-agent",
    api_key="your-key-here",
    base_url="http://localhost:8000"
)

2. Create/Retrieve Persistent Session

session = client.create_session(user_id="user-123")
session = client.get_session(user_id="user-123", session_id="existing-uuid")

3. Store Memory During Conversation

mm = session.memory_manager

mm.create_episodic(
    content="User asked about hosting prices",
    metadata={"type": "inquiry", "intent": "budget"}
)

mm.create_semantic(
    content="User prefers open-source solutions",
    metadata={"confidence": 0.9, "source": "inference"}
)

4. Search Relevant Memories

recent_memories = mm.get_episodic(
    filter_metadata={"type": "inquiry"},
    time_range="30m"
)

knowledge = mm.search_semantic(query="user preferences", top_k=5)

5. Integrate with Hermes Agent

from hermes_agent import HermesAgent

agent = HermesAgent(
    model="deepseek-chat",
    system_prompt="You are a personal assistant who remembers everything.",
    session_id=session.id
)

def fetch_memory(context: str) -> str:
    memories = mm.search_semantic(query=context, top_k=3)
    return "\n".join([m.content for m in memories])

agent.register_tool(fetch_memory)
response = agent.run("What do you know about me?")

Real Use Cases

Personal Assistant

An assistant that learns your preferences over weeks, remembers past commitments, and adapts its tone.

Technical Support

An agent that remembers all previous tickets — solved issues, software versions, attempted workarounds.

Development Agent

An agent that remembers architectural decisions you made together, preferred code patterns, recurring project issues.

Personalized Education

An AI tutor that knows exactly where the student left off, which concepts they master, and what needs practice.

Conclusion

Honcho solves one of the most fundamental problems for truly useful AI agents: memory that persists.

The separation into episodic, semantic, and procedural memory isn’t just a technical detail — it’s a model that reflects how we organize knowledge.

If you’re building agents that need continuity, personalization, and learning over time, Honcho + Hermes Agent is a powerful open-source combination worth exploring.

Next Steps

Enjoyed this? Share it with fellow AI agent builders.

← Back to blog