The Chronicle Memory System replaces sprawling, unmanaged context windows with structured, graph-connected memory. Instead of feeding an LLM an unbounded chat history, Chronicle maintains continuity by dynamically tracking context, using deterministic workflows for context evaluation, and giving users granular, direct control over what the AI remembers.

1. The Active Conversation Window

Most memory architectures either pass the entire chat history or rely on simple similarity search across every past message. Chronicle uses a targeted, user-configurable conversation window, defaulting to 15 turns of user and assistant messages, to evaluate immediate intent without context drift.

Within this window, conversation turns can be modified or pruned:

  • Message Editing & Deletion: Users can edit prior prompts or delete an entire conversation round.

  • Granular Feedback Signals: Each turn includes explicit feedback hooks (Thumbs Up, Neutral, Thumbs Down) that dictate how the turn influences memory generation:

    • Thumbs Up: Confirms the assistant response and selected context entries were accurate.
    • Neutral (Default): Indicates an acceptable response without strong validation.
    • Thumbs Down: Marks the entire round as invalid. The memory pipeline explicitly ignores both the user message and assistant response from that round during future context evaluations.

2. Multi-Stage Pipeline Logic (Context Selection to Response)

Chronicle Memory Ingestion Pipeline
Chronicle Memory Ingestion Pipeline

Rather than relying on fully autonomous “agents”—which often introduce unpredictability—Chronicle uses deterministic, multi-stage logic paired with specialized system prompts.

  1. Stage 1: Context Matching
    • Inputs: Active conversation window, currently active entities, adjacent nodes in the Categorized Context Graph (CCG), and any user-checked entities.
    • Goal: Determine whether the user is continuing an existing topic or shifting focus, and select the top k (configurable, defaults to 5) relevant context entries.
  2. Stage 2: Response Generation
    • Inputs: User prompt combined with the top k selected context entries from Stage 1.
    • Goal: Synthesize the contextual knowledge to produce the assistant’s response.

3. Memory Structure: Categorized Context Graph (CCG)

Chronicle organizes memory into a graph structure that users can view and interact with as either a tree hierarchy or a network graph.

Direct User Overrides & Graph Traversal

  • Active Checkboxes: Users can manually check entries in the tree/graph to mark them as active for the current conversation.
  • Parent-Child Logic: When a user explicitly selects a child entry, parent entities are automatically included to preserve foundational context. Unselected sibling or cross-linked nodes remain dormant unless selected by Stage 1.

Anatomy of a Context Entry

Every memory node in the graph contains both standardized front matter and entry-specific payload details:

  • Common Fields:
    • Short Summary: A 1–2 sentence abstract for quick Stage 1 evaluation.
    • Full Summary: Detailed breakdown of the memory’s core facts.
    • Full Context: Raw, detailed payload of the memory.
    • Linked Conversation Rounds: Direct references to the exact chat rounds that created or updated the entry.
  • Categorized Types: Memory entries are strongly typed. Predefined types include:
    • General Purpose Markdown
    • Andrej Karpathy-Style Wikis
    • Entities: People, Places, and Things
    • Timelines: Concrete (dated events) vs. Ordinal Abstract (sequential events), categorized across history, fiction, and future planning.

4. Custom Memory Types & System 1 Processing

Users can define custom context types tailored to specific domain needs. Each custom type includes user-defined summarizing modes that control how memories are created and updated.

  • Blueprint Execution Graphs: Summarizing modes are constructed like visual logic graphs (similar to Unreal Engine Blueprints).
  • Deterministic System 2 Logic + System 1 Prompts: The blueprint orchestrates programmatic flow alongside fast, template-based LLM calls (“System 1” calls) to extract facts, format front matter, and assign graph relationships deterministically.