Time-Series Indexing

The fundamental principle of time-series indexing is the immutable, timestamp-based ordering of data points. This creates a primary sequence where each entry's position is defined by its temporal coordinate, enabling operations like:

• Range queries (e.g., SELECT * FROM sensor_data WHERE time > '2024-01-01')
• Time-travel queries to reconstruct past system states
• Efficient append-only writes, as new data is always inserted at the chronological end. This ordering is the backbone for analyzing trends, seasonality, and event sequences.

To manage high-velocity data, time-series indexes implement partitioning by time intervals (e.g., by hour, day, or month). This is a critical optimization that:

• Accelerates queries by allowing the database to read only the relevant time partitions.
• Simplifies data lifecycle management; old partitions can be compressed, moved to cold storage, or deleted as a unit.
• Enables parallel processing across partitions. Systems like Apache Druid and TimescaleDB use hypertables or segments based on time to achieve this scalability.

Time-series data is often recorded at high resolution but analyzed at multiple granularities. Indexing systems support aggregation and rollup to create lower-resolution summaries.

• Raw data at millisecond resolution is stored for detailed debugging.
• Rolled-up aggregates (e.g., 1-minute averages, 5-minute maximums) are pre-computed and indexed for fast dashboard queries over long time ranges. This multi-resolution approach balances storage costs with query performance, a concept central to time-series databases (TSDBs) like InfluxDB.

Sequential data points are often highly correlated. Time-series indexes leverage specialized temporal compression algorithms that exploit this predictability.

• Delta-of-delta encoding for timestamps, storing only the change in the time interval.
• Run-length encoding (RLE) or Gorilla compression for slowly changing metric values.
• Dictionary encoding for repeating tag values (e.g., sensor IDs). This reduces storage footprint by 90% or more compared to general-purpose databases, enabling cost-effective long-term retention.

Beyond time, queries filter on metadata tags (dimensions) and field values (metrics). A robust time-series index creates secondary structures for these.

• Tag Indexing: Inverted indexes on key-value pairs (e.g., host=server-01, region=us-west) allow fast filtering to specific series.
• Field Indexing: For high-cardinality numeric fields, specialized indexes like Bitmap indexes or B+ trees enable range queries on values (e.g., temperature > 90). This dual-indexing strategy is exemplified by the InfluxDB TSM engine and Prometheus's TSDB.

For agentic memory, a time-series index is not just for storage; it's a substrate for temporal reasoning. It enables:

• Event correlation by joining multiple indexed streams based on time windows.
• Sequential pattern mining to discover frequent event chains.
• Temporal abstraction, where low-level data is transformed into higher-level, interval-based states. When combined with a temporal knowledge graph, the indexed series provide the raw event data needed to infer causal relationships and maintain a coherent narrative of agent experience.

A continuous, time-ordered sequence of discrete events or state changes that serves as the foundational data source for temporal memory in autonomous agents. Event streams are the raw input for time-series indexing systems, providing the immutable, append-only log of an agent's experiences. Common sources include sensor telemetry, user interactions, API calls, and system logs. Key characteristics include:

• Immutability: Events are never modified, only appended.
• High Volume: Can generate millions of events per second in production systems.
• Schema Evolution: The structure of events may change over time, requiring flexible indexing.

A fixed-size, in-memory data structure that stores the most recent events or states in chronological order, acting as a short-term, rolling window of agent experience. This is a core component for real-time processing and immediate context. When full, the oldest entries are evicted (First-In-First-Out). Engineering use cases include:

• Real-time Feature Computation: Calculating moving averages or detecting anomalies within the latest N events.
• Context Window Management: Providing the immediate history to a language model's limited context.
• State Management: Maintaining the agent's current operational context before committing to long-term storage.

A database system optimized for storing, querying, and analyzing time-stamped data points generated at high frequency. TSDBs are the persistent storage layer for indexed temporal data. They use specialized storage engines and compression algorithms for efficient handling of sequential writes and time-range queries. Examples and features include:

• Examples: InfluxDB, TimescaleDB, Prometheus.
• Columnar Storage: Data is stored by timestamp and metric, enabling fast aggregation.
• Downsampling & Retention: Automatically reduces data granularity over time and deletes old data based on policies.
• Native Time-Based Queries: Support for queries like SELECT * FROM metrics WHERE time > now() - 1h.

A knowledge graph where facts or relationships are associated with timestamps or valid time intervals, enabling querying over evolving knowledge states. This extends standard indexing by adding semantic relationships between entities across time. It answers questions like "What was the CEO's title during Q3 2023?" Key components are:

• Temporal Triples: Standard subject-predicate-object triples augmented with a time interval or instant.
• Versioning: Entities and relationships can have multiple versions, each valid for a specific period.
• Temporal Reasoning: Supports queries for facts that were true at a specific time or that changed over time.

The process of segmenting a continuous event stream or time-series into discrete, meaningful units or episodes based on temporal boundaries or semantic shifts. This is a critical pre-processing step before indexing, transforming raw sequences into searchable memory items. Chunking strategies include:

• Fixed-Time Windows: Simple segmentation every N seconds/minutes.
• Event-Driven Windows: A new chunk begins when a specific type of event occurs (e.g., "session_start").
• Content-Aware Segmentation: Using ML models to detect natural breaks in activity or topic.
• Hybrid Approaches: Combining time, event, and semantic signals for optimal chunk granularity.

A search technique that incorporates temporal filters or recency biases to prioritize memory items based on their timestamp or relevance to a specific time period. This ensures an agent's memory recall is contextually appropriate to the "when" of a query. Implementation patterns include:

• Temporal Filtering: Hard constraints like timestamp >= '2024-01-01'.
• Recency Scoring: Boosting the relevance score of newer items in hybrid search (e.g., combining semantic similarity with a decay function based on age).
• Temporal Proximity: Finding items that are close in time to a reference event, even if semantically different.
• Seasonal Context: Retrieving data from the same time period in previous cycles (e.g., "last January").