The Cold Start
Problem in Multi-Agent Memory Systems

When The Consilium receives a query, ten agents wake up with identical amnesia. Each carries its system prompt — its identity, its domain, its epistemic fingerprint — and nothing else. No record of what was asked yesterday. No accumulated understanding of the user. No memory of prior tensions or syntheses. The system prompt is the only persistent thing. Everything else is cold.

§1 The Network in a Stateless State

Stateless architecture was a deliberate choice made early in the system's design: simplicity of deployment on Cloudflare Workers, clean isolation between queries, elimination of stale context errors, and the interpretability benefit of knowing that any given output was produced solely from the current input plus the fixed system prompt.

Eighteen months of operation later, the costs are visible. Users re-establish context that was built in prior sessions. Agents have no memory of tensions they resolved. The system that analyzed three prior acquisitions for the same user treats query four as if queries one through three never happened.

§2 What Statelessness Provides

The standard framing of stateless architecture focuses on what it lacks. The more useful framing is what it actively provides — because those provisions are at risk when memory is introduced.

2.1 Clean Agent Identity

Each agent has an engineered epistemic identity: a set of priors, a domain of authority, a characteristic type of skepticism. In a stateless system, the identity is perfectly consistent across every query. The contrarian is always the contrarian. The economist always enters the room with the same priors. Introduce persistent memory and the identity becomes subject to drift — an agent that has "seen" 200 prior queries about a market will develop implicit priors not in its system prompt. Those priors may be accurate, which looks like learning, or artifacts of query history, which looks like bias.

2.2 Query Independence

In the current system, the answer to query N has no causal relationship to the answer to query N-1. Errors in a prior session cannot compound into subsequent sessions. A confident-wrong answer on Monday does not contaminate Tuesday. In a system with persistent memory, a confident incorrect claim from a prior session could seed the context for future sessions — the temporal equivalent of within-session propagation, but potentially much harder to detect.

§3 The Costs — Precisely Counted

§4 The Contamination Problem

The intuitive solution to cold start is to inject prior context into the agent's context window at session start. The technical implementation is straightforward. The contamination problem emerges from three sources that naive implementations consistently underweight:

// The three contamination vectors — live status as of March 2026

// Vector 1: Stale Priors
const stalePriorRisk = {
  trigger:    'memory_age > decay_threshold',
  mitigation: 'timestamp all entries, apply relevance decay fn',
  status:     'IMPLEMENTED — proptechusa-memory v0.3'
}

// Vector 2: Error Compounding
// Confident-wrong in session N becomes prior in session N+1
// No mechanism to distinguish validated vs unvalidated conclusions
const errorCompoundingRisk = {
  trigger:    'unvalidated_memory injected as prior',
  mitigation: 'confidence tagging + outcome validation layer',
  status:     'OPEN — validation layer not yet built'
}

// Vector 3: Identity Drift (most counterintuitive)
// Agent memories of own prior outputs create anchoring
// Undermines epistemic independence that architecture requires
// Solution: NO agent-specific memory. Global user context ONLY.
const identityDriftRisk = {
  trigger:    'agent receives memory of own prior outputs',
  mitigation: 'agent memory isolation — user context only, never agent context',
  status:     'IMPLEMENTED by architectural design'
}

// The rule that follows from all three:
// Agents know what the USER brought to the system.
// Agents do NOT know what they previously said about it.

§5 The Layered Architecture

The design of proptechusa-memory reflects constraints derived from the contamination analysis. The architecture is not "add memory to agents" — it is "add a memory layer between sessions and agents, with explicit rules about what crosses the boundary."

§6 Open Problems

§7 Conclusion

The cold start problem and the contamination problem are the same problem viewed from opposite sides. Every mechanism that reduces cold start introduces contamination risk. Every mechanism that prevents contamination reintroduces cold start. The design question is not which problem to solve but which tradeoff to accept at which layer.

The architecture described here accepts cold start at the agent identity layer — agents do not remember their prior outputs — in exchange for contamination protection. It accepts partial warm start at the user context layer in exchange for the re-establishment overhead cost. It defers the calibration and tension resolution problems to a future outcome validation layer that has not yet been built.

This is not a complete solution. It is an honest accounting of where a live system currently sits in a tradeoff space with no clean resolution.