Agent conversation history is shared state, not a transcript

Conversation history in a multi-agent system is shared state, not a transcript. Agents read it to decide what is true, what has been assigned, which effects have occurred, and what remains unresolved. Once a message can change another agent’s next action, its ordering, identity, provenance, and retention become state-management concerns.

The historical lineage from KQML and FIPA communication languages to modern agent protocols keeps rediscovering the same idea: a message is not merely text. It has a sender, recipient, performative or intent, correlation identity, content type, and relationship to a task. Flatten those fields into a chat string and the system loses the difference between a proposal, an observation, an approval, and a completed effect.

I prefer an append-only event log as the canonical history. Every message receives a stable ID, author, timestamp, thread or task key, schema version, and causal parent. Current state is a projection over that log; snapshots are derived accelerators. This gives provenance, prefix-based time travel, and replay without pretending the model itself is deterministic. It also makes conflicts visible rather than letting the latest prose silently overwrite an earlier commitment.

That design sharpens the distinction in session state versus long-term memory. The conversation log records what happened in the working process. Durable memory records selected claims that survived validation, scope rules, and consolidation. Copying an entire transcript into memory mixes temporary hypotheses, rejected plans, private tool output, and final facts. Promotion from history to memory should be an explicit governed operation.

Shared state also requires projections. An agent should not receive every message merely because the log retains it. Views need tenant, task, role, sensitivity, and purpose filters. A verifier may need evidence and decisions but not private user data; a worker may need its assignment and dependency status but not unrelated branches. The canonical log preserves history while context assembly exposes the minimum valid slice.

Recovery follows from the same model. Durable execution needs checkpoints, but replay must know which messages describe intentions and which confirm committed side effects. Idempotency keys and typed effect states prevent a recovered worker from sending the same email or charging the same account twice. The history is only a recovery contract when its event semantics are strong enough to distinguish proposed, attempted, committed, and compensated work.

Deletion cannot mean editing the past casually. Privacy may require erasing message content, while audit may require retaining that an authorized event occurred. I would separate encrypted payloads from durable event envelopes, apply scoped retention to each, and record tombstones without preserving forbidden content. Shared state needs deletion semantics as carefully as it needs append semantics.

There is one precise concession: a single-user, read-only assistant session with no delegation, external effects, or resume requirement can reasonably treat history as a disposable transcript. The moment multiple actors, durable work, approvals, or shared resources enter the loop, that simplification stops being honest. The chat has become coordination state whether the implementation acknowledges it or not.

Operationally, I want telemetry to preserve decisions and the history to preserve their inputs and consequences. A run should answer which message authorized an action, which evidence changed a plan, and which projection each agent saw. That is why a canonical event model matters across harnesses. Treating history as shared state does not make every message permanent or globally visible. It makes retention, deletion, visibility, ordering, and replay explicit — the minimum discipline for agents coordinating through language.