Oblivion Documentation

Oblivion is a self-adaptive memory activation framework composed of four cognition modules orchestrated by an Executor agent. Each module can be used standalone or combined into a full pipeline.

Oblivion architecture diagram
Figure: Architecture design of Oblivion framework. The Executor orchestrates interactions between the Environment and a hierarchical memory structure: Dynamic Procedural (L₁), Semantic (L₂), Episodic (L₃), organized by accessibility scores. Working Memory connects to the memory through the Decayer and the Activator for read path (activation, →), and the Recognizer and the Memory Manager for write path (reinforcement, →). Natural decay processes move memories toward lower accessibility over interaction counts.

Module Documentation

Functional Description

System architecture, problem statement, and design principles of the Oblivion framework.

Executor Agent

Orchestration flow, thinking loop, metrics reference, and the full cognitive pipeline.

Decayer Module

Uncertainty assessment, Ebbinghaus decay, two-tier uncertainty model, and routing decisions.

Activator Module

Query expansion DAG, memory retrieval, RRF curation, and buffer merging.

Recognizer Module

Memory extraction, utility assessment, topic construction, and reward criteria.

Memory Manager Module

Qdrant vector storage, CRUD operations, namespace filtering, and embedding providers.

Execution Flow

The Executor orchestrates a Recognizer-first pipeline. Every interaction begins with the Recognizer extracting memories, then conditionally enters the Decayer→Activator thinking loop for questions or rule statements.

Running Example

Consider a user saying: “I visited Tokyo last autumn and spent two weeks exploring the city.”

  1. Recognizer classifies this as a STATEMENT, extracts a semantic memory (“User visited Tokyo last autumn, two-week trip”), and assigns it to the personal_life cluster.
  2. Decayer is skipped — statements do not trigger the thinking loop.
  3. Memory Manager stores the new memory in Qdrant with an initial utility score.
  4. Response generation uses the current buffer context.

Later, the user asks: “What places did I visit on my last trip?”

  1. Recognizer classifies this as a QUESTION.
  2. Decayer evaluates buffer sufficiency — Tier 1 (LLM) and Tier 2 (cosine similarity) both indicate high uncertainty → requires_activation=True.
  3. Activator expands the query into sub-queries (e.g., “travel experiences”, “trip locations visited”), retrieves the Tokyo memory from Qdrant, and curates the buffer.
  4. Response generation uses the enriched buffer — the agent recalls Tokyo, Meiji Shrine, and Shinjuku.
  5. Decay reinforcement — the Tokyo memory’s decay score is boosted because it was used.

If the user immediately asks the same question again, the Decayer determines that the buffer already contains the relevant memories (HIGH confidence), so the Activator is not triggered — the response is generated directly from the existing buffer.

Metrics & Logging

Oblivion provides four logging mechanisms at different granularities. See the Executor documentation for the full metrics reference.

LoggerGranularityOutput
IntermediateLogger Per-interaction snapshots intermediate_*.json — Decayer/Activator/Buffer states, judge scores
DecayTracker Per-memory timelines Decay score evolution, reinforcement events, access counts
ActivatorTracker Trigger patterns Trigger rate, uncertainty levels, cluster patterns
MetricsCollector Aggregated run-level Mean/std/p50/p95 for latency, tokens, judge scores