Sequential Memory

The fundamental property of sequential memory is the preservation of chronological order. Events are stored with precise timestamps or positional indices, enabling accurate reconstruction of the sequence. This is distinct from semantic memory, which organizes information by meaning.

• Example: An agent tracking a user's conversation must recall that "I want a pizza" was said before "Actually, make it a salad" to understand the intent change.
• Implementation: Often uses append-only logs or time-series databases where data is immutable and ordered by insertion time.

Continuous experience is segmented into discrete, meaningful units called events. Temporal chunking algorithms identify boundaries based on changes in context, agent goals, or semantic content.

• Key Mechanism: Event Segmentation transforms a stream of sensor data or text into a series of (timestamp, event_description) tuples.
• Purpose: Enables efficient storage, retrieval, and reasoning over coherent episodes rather than raw, high-frequency data streams.

Reasoning and retrieval often operate within a bounded interval of recent history. A temporal context window defines the sliding range of past events considered relevant for the current task.

• Dynamic Sizing: The window may expand or contract based on task complexity or the need for long-term coherence.
• Relation to LLMs: This is an architectural parallel to the fixed token context window of a transformer, but implemented at the agent system level for long-horizon tasks.

Beyond simple order, sequential memory infers and stores relationships between events. This enables temporal reasoning about cause and effect.

• Event Causality Graphs: Represent events as nodes with directed edges labeled causes, precedes, or enables.
• Use Case: An agent debugging a system failure can traverse a causality graph from the error back through the chain of preceding API calls and state changes.

The memory supports two key operations: recalling past sequences and predicting future ones. Recall is the faithful retrieval of past events in order. Prediction uses patterns in past sequences to forecast likely next events.

• Models Used: Sequence prediction often employs LSTMs, Transformers, or Temporal Convolutional Networks (TCNs).
• Application: In a logistics agent, predicting the next step in a package's journey based on its historical transit sequence.

Sequential memory rarely operates in isolation. It is integrated with semantic memory (for meaning) and episodic memory (for specific experiences).

• Episodic Buffer: A theoretical component that binds sequential events with their sensory and semantic context into a cohesive "episode."
• Hierarchical Memory: Low-level event sequences can be abstracted into higher-level temporal abstractions (e.g., "morning routine") stored in long-term memory.

A continuous, time-ordered sequence of discrete events or state changes that serves as the primary data source for building sequential memory. In agentic systems, this could be user interactions, API call results, sensor readings, or internal agent actions.

• Characteristics: Append-only, immutable, and high-velocity.
• Storage: Often handled by log-based systems like Apache Kafka or dedicated time-series databases (TSDBs).
• Use Case: Provides the raw chronological feed from which meaningful episodes and temporal patterns are extracted.

A fixed-size, in-memory data structure that stores the most recent N events in exact chronological order. It acts as a short-term, rolling window of immediate agent experience, analogous to a CPU cache for temporal data.

• Mechanism: Operates on a First-In-First-Out (FIFO) eviction policy; when full, the oldest event is discarded to make room for the newest.
• Purpose: Provides low-latency access to recent context for real-time decision-making without querying a persistent store.
• Engineering Consideration: Size is a critical hyperparameter balancing recency against memory footprint and relevance.

The algorithmic process of segmenting a continuous event stream into discrete, semantically coherent units or episodes. This transforms a raw sequence into a structured memory with logical boundaries.

• Methods: Can be rule-based (e.g., segment on session timeout), learned via change-point detection algorithms, or induced by temporal attention shifts.
• Output: Creates 'chunks' that become the atomic units for storage, retrieval, and reasoning in hierarchical memory structures.
• Benefit: Reduces cognitive load for the agent by grouping related events, enabling reasoning at a higher level of abstraction.

The transformation of an ordered list of items (events, states) into a fixed-dimensional vector representation that preserves information about the order and relationships of the elements.

• Techniques: Includes models like Recurrent Neural Networks (RNNs), Long Short-Term Memory (LSTM) networks, Transformers with positional encodings, and temporal convolutional networks.
• Purpose: Creates an embedding that can be used for similarity search, sequence prediction, or as a compressed summary of an episode for storage in a vector database.
• Key Challenge: Designing encoders that are invariant to irrelevant temporal noise while sensitive to meaningful order changes.

A search technique that incorporates temporal filters or biases to prioritize memory items based on their timestamp, recency, or relevance to a specific time period in the query context.

• Implementation: Can involve hybrid search combining semantic similarity (via vector search) with time decay functions (e.g., exponential decay based on age) or explicit timestamp filtering.
• Example: An agent troubleshooting a system error might prioritize logs from the last 5 minutes over semantically similar logs from last week.
• Systems: Requires databases that support multi-dimensional indexing, such as vector databases with metadata filtering or specialized time-series databases.

A knowledge graph structure where nodes represent events and directed edges represent inferred causal or temporal precedence relationships (e.g., 'causes', 'happens before').

• Function: Enables temporal reasoning beyond simple sequence, allowing agents to answer 'why' questions and predict downstream effects of actions.
• Construction: Built through pattern mining, statistical correlation analysis, or leveraging large language models for causal inference from text descriptions.
• Relation to Sequential Memory: Sits atop a raw sequential store, adding a layer of interpretable, relational structure that captures the 'narrative' of events.