💻 computer science

ESAA-Conversational: An Event-Sourced Memory Layer for Continuity, Handoff, and Curation Across Heterogeneous LLM Coding Agents

This paper introduces ESAA-Conversational, an event-sourced memory layer that enables heterogeneous LLM coding agents to maintain continuity and collaborate across sessions by capturing visible conversation turns into a shared, append-only log and projecting deterministic read models for state, decisions, and tasks without requiring direct agent-to-agent communication or constant LLM inference.

Original authors: Elzo Brito dos Santos Filho

Published 2026-06-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Elzo Brito dos Santos Filho

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a project manager leading a team of four very different specialists: a coder, an architect, a researcher, and a designer. Each of them is an AI agent (like Codex, Grok, or Claude). They are brilliant, but they all have a major flaw: they have short-term memory and they don't talk to each other.

When the Architect finishes a meeting, they write their notes in a private notebook. When the Coder starts their shift, they have no idea what the Architect decided unless you, the human, manually copy-paste those notes into a new chat. This is slow, messy, and you often lose important details.

ESAA-Conversational is a new system designed to fix this. It acts like a centralized, shared "Project Logbook" that sits between all these different AI agents.

Here is how it works, using simple analogies:

1. The "Black Box" Recorder (Mechanical Capture)

Instead of asking the AI to "remember" things, the system quietly installs a security camera (called a hook or watcher) over the AI's screen.

What it does: Every time the AI types a message, the camera snaps a photo and writes it into a digital logbook called activity.jsonl.
The Rule: This logbook is append-only. Think of it like a flight recorder on a plane. Once a line is written, it cannot be erased or changed. It is the "Source of Truth."
Why it matters: The AI doesn't need to do any extra thinking to save its work. The system just records the raw evidence automatically.

2. The "Executive Summaries" (Projected Read Models)

A raw logbook with 500 pages of chat is useless if you just want to know the current plan. So, the system automatically generates clean, readable summaries based on that logbook.

The Analogy: Imagine a librarian who reads the messy, handwritten daily logs of a construction site and then writes three clean reports for the foreman:
- state.md: "Here is where we are right now."
- decisions.md: "Here are the 5 big choices we made and why."
- tasks.json: "Here is the list of things still left to do."
The Magic: These reports are generated automatically. No one manually edits them. If the logbook changes, the reports update instantly. This ensures the summaries always match the raw truth.

3. The "Handoff" (Continuity)

When the Architect finishes their shift and the Coder starts, the Coder doesn't need to read the whole 500-page logbook.

The Process: The Coder simply asks the system for a "Handoff." The system hands them the handoff.md (a summary of what happened) and a specific "window" of the last 20 messages relevant to their task.
The Benefit: The Coder starts working immediately with full context, without wasting time reading irrelevant chatter or losing track of previous decisions.

4. The "Human-in-the-Loop" (Curation)

The system distinguishes between what happened (evidence) and what matters (decisions).

Evidence: The AI typing "I think we should use Python" is just a turn in the log.
Curation: If the AI (or a human) says, "Okay, we have decided to use Python," the system records this as a formal Decision Event.
Why it matters: This separates the noise of the conversation from the durable rules of the project. The system knows the difference between a random thought and a final rule.

5. Privacy and Safety

The paper emphasizes that this system is designed to be safe for public use.

The "Greenfield" Package: When the developers released the tool, they gave everyone a brand new, empty logbook. They did not share their own private conversations.
The "Do Not Share" List: The system automatically hides the messy log files from public view (like a .gitignore file), ensuring that sensitive private chats don't accidentally get uploaded to the internet.

The Real-World Test

The authors tested this system on themselves. They used different AI agents to design and build the system while the system was recording their own conversations.

Result: The agents successfully collaborated without ever talking directly to each other. They just read the shared logbook and the summaries.
Outcome: They proved that you can switch between different AI tools (like switching from Grok to Claude) without losing the thread of the conversation, as long as they all read from the same shared log.

In Summary

ESAA-Conversational is a tool that stops AI agents from having amnesia. It acts as a shared, unchangeable diary that records everything, automatically writes clean summaries for the next person to read, and ensures that when you switch tools, you don't have to start from scratch. It turns the chaotic process of switching AI assistants into a smooth, continuous workflow.

Technical Summary: ESAA-Conversational

Problem Statement

Software development workflows increasingly rely on heterogeneous Large Language Model (LLM) agents (e.g., Codex, Grok, Claude Code), where developers switch tools based on context window limits, cost, or specific subtask suitability. However, continuity across these agents is currently fragile. Each agent persists conversation in private, vendor-specific logs, leading to conversational state drift: goals, decisions, rationales, and open tasks established with one agent are not reliably available when another takes over.

Current remedies involve manual copy-pasting of context, which is lossy, expensive in tokens, and conflates the distinct activities of capturing conversational evidence and interpreting that evidence. There is a lack of a shared, deterministic memory layer that allows agents to collaborate without a direct agent-to-agent channel or a common runtime protocol.

Methodology

The paper proposes ESAA-Conversational, a domain specialization of the Event-Sourced Agent Architecture (ESAA) designed to govern shared conversational memory. The methodology treats the visible conversation as a local event store, separating mechanical capture from human/agent judgment.

Core Architectural Principles

Inverted Ingestion: Instead of requiring agents to speak a common protocol, the system ingests native logs, hooks, or watchers from heterogeneous agents. A deterministic adapter normalizes these visible turns into a single, append-only event log (activity.jsonl).
Mechanical Capture vs. Curation:
- Turns (Evidence): Visible conversation is captured mechanically without LLM inference.
- Decisions & Tasks (Judgment): Durable decisions and operational tasks are recorded explicitly through domain commands (decide, task). This creates a strong boundary where turns serve as evidence, while curated events represent durable knowledge.
Event Sourcing & CQRS: The system follows Command Query Responsibility Segregation (CQRS).
- Write Path: Agents and hooks append events to activity.jsonl.
- Read Path: The system deterministically projects read models (e.g., handoff.md, state.md, decisions.md, tasks.json) from the log. These models are not manually edited; they are reconstructed.
Context Engineering: To address attention degradation in long contexts, the system provides paginated context commands. A "cold" agent does not ingest the full log but requests a selective window (e.g., last $N$ turns, topic-filtered, or around a specific event) via the CLI.

Implementation (v1.1.0)

The public release is a greenfield PowerShell-based CLI tool (conversation-esaa) that includes:

Commands: init, enable-hooks, sync, project, verify, context, decide, and task.
Isolation: Enforces workspace_root boundaries to prevent log mixing.
Concurrency: Uses a simple write-path lockfile (run/*.lock) to serialize operations.
Privacy: The public distribution starts with an empty log. Sensitive files are excluded via .gitignore, and the system avoids capturing hidden reasoning or system prompts.

Key Contributions

The paper makes five specific contributions:

Domain Specialization: Defines ESAA-Conversational as a specific application of event sourcing for conversational memory across heterogeneous agents.
Inverted Ingestion Formalization: Establishes a method to read native agent logs and normalize them into events without requiring a shared agent runtime.
Architectural Boundary: Formalizes the separation between mechanical capture (turns as evidence) and curation (decisions/tasks as explicit events).
Public Release Specification: Describes the v1.1.0 release, detailing the CLI, projected read models, paginated context, and workspace isolation mechanisms.
Self-Referential Case Study: Reports on the system being designed, implemented, and reviewed by distinct agents using the very conversational memory layer it builds.

Results and Case Study

The paper presents a self-referential case study where the ESAA-Conversational system was used to manage its own development lifecycle.

Scale: The development laboratory log contained 570 events (562 conversation_turn events) involving Codex (304), Claude (79), and Grok (67).
Collaboration: Heterogeneous agents collaborated on design decisions (e.g., hook design, command semantics) without direct communication. An agent could inspect another's work by querying the shared log (e.g., context --agent grok --last 20).
Defect Resolution: The workflow successfully identified and fixed a defect in legacy event filtering. The diagnosis, fix, and verification were recorded as explicit decision and task events, demonstrating the practical utility of the curation surface.
Validation: The study confirms the operational viability of the v1.1 design in a sustained, real-world multi-agent workflow and validates the value of selective, deterministic handoff.

Significance and Claims

The paper claims that ESAA-Conversational offers a distinct architectural boundary for multi-agent systems:

Continuity without Common Runtime: It enables continuity across agents that do not share a protocol or runtime, relying instead on a shared, deterministic ledger.
Token Economy: It reduces token consumption by replacing manual context copying with deterministic file projection and paginated reading. The "zero tokens" claim applies to the mechanical capture and projection processes, not the agents' reasoning.
Auditability: It provides operational auditability (tracking what was captured, decided, and projected) without promising strong forensic auditability (e.g., cryptographic signatures or hash chains are deferred to future work).
Privacy: By treating the public distribution as a greenfield package and excluding private logs, it offers a privacy model where development can generate sensitive data while distribution remains clean.

The authors emphasize that this is not a new semantic memory system (e.g., vector databases) but a deterministic ledger that prevents indexes from becoming the source of truth. The system prioritizes a simple, local, and verifiable tool over complex infrastructure, deferring features like snapshots, cold replay, and semantic search to future iterations.